public PrivateAddDocumentReturn AddDocument(IDictionary<string, List<string>> index, params DocumentToStore[] contents)
        {
            // Mide el tiempo de la operación de almacenamiento
            Stopwatch sw = Stopwatch.StartNew();

            List<FileInfo> FileInfoCollection = new List<FileInfo>();

            // Este try es solo para eliminar los archivos temporales al final del método
            try
            {
                // puede ser null o venir sin elementos?, SI. En ese caso, solo se almacena un registro sin documento
                if (contents != null && contents.Length > 0)
                {
                    foreach (DocumentToStore content in contents)
                    {
                        if (content == null)
                            continue;

                        if (string.IsNullOrEmpty(content.Extension))
                            throw new DWManagerExtensionIsNullOrEmptyException();

                        if (content.Content == null)
                            throw new DWManagerBas64IsNullException();

                        // El nombre del archivo en la ruta temporal
                        string foo = Path.ChangeExtension(Guid.NewGuid().ToString(), content.Extension);
                        foo = Path.Combine(Path.GetTempPath(), foo);

                        try
                        {
                            File.WriteAllBytes(foo, content.Content);
                        }
                        catch (Exception ex)
                        {
                            throw new DWManagerInvalidBas64Exception(ex);
                        }

                        FileInfoCollection.Add(new FileInfo(foo));
                    }
                }

                // Los índices del documento
                Document documetIndex = this.CreateDocumentIndexAndThrowExceptionWhenIndexNotFound(index);

                // Almacena el documento, lanza el evento y devuelve la información del documento
                Document AddedDocument = this.CurrentFileCabinet.UploadDocument(documetIndex, FileInfoCollection.ToArray());
                sw.Stop();

                if (this.OnAddDocument != null)
                    this.OnAddDocument(this, new DWManagerAddDocumentEventArgs(sw.Elapsed, AddedDocument.Id));

                return new PrivateAddDocumentReturn()
                {
                    DWDocID = AddedDocument.Id,
                    DWStoreDateTime = AddedDocument.CreatedAt,
                    DWFileSize = AddedDocument.FileSize,
                    DWTotalPages = AddedDocument.TotalPages,
                    DWSectionCount = AddedDocument.SectionCount
                };
            }
            catch
            {
                throw;
            }
            finally
            {
                foreach (FileInfo fi in FileInfoCollection)
                {
                    try
                    {
                        fi.Delete();
                    }
                    catch { }
                }
            }
        }
		
Document CreateDocumentIndexAndThrowExceptionWhenIndexNotFound(IDictionary<string, List<string>> index)
        {
            // El retorno
            Document CreateDocumentIndexAndThrowExceptionWhenIndexNotFoundReturn = new Document();
            CreateDocumentIndexAndThrowExceptionWhenIndexNotFoundReturn.Fields = new List<DocumentIndexField>();

            // Los índices que no existen en el archivador
            ICollection<string> IndicesNoExistentes = new List<string>();

            // Los índices que no son Keyword, sin embargo especifican más de un valor
            ICollection<string> IndicesConVariosValores = new List<string>();

            // Recorre los índices que se van a pasar al documento.
            // Lo busca en el diccionario, si existe lo agrega a la indexación del documento. Si no, entonces a la lista de índices no existentes.
            foreach (string k in index.Keys)
            {
                FileCabinetField f = null;

                if (this.CurrentFieldCabinetList.ContainsKey(k.ToUpper()))
                    f = this.CurrentFieldCabinetList[k.ToUpper()]; // Aquí esta el truco de las mayúsculas

                if (f != null)
                {
                    DocumentIndexField docIndfield = null;

                    if (f.DWFieldType == DWFieldType.Keyword)
                    {
                        DocumentIndexFieldKeywords dfk = new DocumentIndexFieldKeywords()
                        {
                            Keyword = new List<string>(index[k])
                        };
                        docIndfield = DocumentIndexField.Create(f.DBFieldName, dfk);
                    }
                    if (f.DWFieldType.Equals(DWFieldType.Table))
                    {
                        try
                        {
                            docIndfield =
                            new DocumentIndexField()
                            {
                                FieldName = "TablaManifiesto",
                                ItemElementName = ItemChoiceType.Table,
                                Item = new DocumentIndexFieldTable
                                {
                                    Row = new List<DocumentIndexFieldTableRow>
                                    {
				                        // Table Fields are right now case sensitive!
				                        // Please use exact same writing like in database.
				                        // Bug will be resolved soon!

				                        new DocumentIndexFieldTableRow()
                                        {
                                            ColumnValue = new List<DocumentIndexField>()
                                            {
						                        //prefix INVOI_ needed here (Database Name)
						                        DocumentIndexField
                                                    .Create("NumVenta", "asdf"),
                                                DocumentIndexField
                                                    .Create("DocLegal", "qwerty"),
                                                DocumentIndexField
                                                    .Create("Cliente", "fggggg"),
                                            }
                                        },
                                        new DocumentIndexFieldTableRow()
                                        {
                                            ColumnValue = new List<DocumentIndexField>()
                                            {
						                        //prefix INVOI_ needed here (Database Name)
						                        DocumentIndexField
                                                    .Create("NumVenta", "asdf"),
                                                DocumentIndexField
                                                    .Create("DocLegal", "qwerty"),
                                                DocumentIndexField
                                                    .Create("Cliente", "fggggg"),
                                            }
                                        },
                                        new DocumentIndexFieldTableRow()
                                        {
                                            ColumnValue = new List<DocumentIndexField>()
                                            {
						                        //prefix INVOI_ needed here (Database Name)
						                        DocumentIndexField
                                                    .Create("NumVenta", "asdf"),
                                                DocumentIndexField
                                                    .Create("DocLegal", "qwerty"),
                                                DocumentIndexField
                                                    .Create("Cliente", "fggggg"),
                                            }
                                        }
                                    }
                                }
                            };   
                        }
                        catch (Exception ex)
                        {

                        }

                    }
                    else
                    {
                        if (index[k].Count > 1)
                        {
                            IndicesConVariosValores.Add(string.Format("[{0}]", k));
                        }
                        else
                        {
                            string index_value = index[k][0];
                            if (f.DWFieldType == DWFieldType.Date)
                            {
                                // Debemos convertir el dato a fecha, que debe venir como dd-mm-yyyy
                                CultureInfo escl_culture = CultureInfo.GetCultureInfo("es-cl");
                                DateTime datetime_value;
                                if (!DateTime.TryParse(index_value, escl_culture, DateTimeStyles.None, out datetime_value))
                                    throw new DWManagerDateFieldInvalidValueException(k, index_value);

                                docIndfield = DocumentIndexField.Create(f.DBFieldName, datetime_value);
                            }
                            else
                            {
                                docIndfield = DocumentIndexField.Create(f.DBFieldName, index_value);
                            }
                        }
                    }

                    if (docIndfield != null)
                        CreateDocumentIndexAndThrowExceptionWhenIndexNotFoundReturn.Fields.Add(docIndfield);
                }
                else
                {
                    IndicesNoExistentes.Add(string.Format("[{0}]", k));
                }
            }

            // Si hay campos no existentes, lanza la excepción, de lo contrario devuelve el documento pre-indexado.
            if (IndicesNoExistentes.Count > 0)
                throw new DWManagerIndexNotFoundException(this.m_filecabinet_name, IndicesNoExistentes);

            // Si hay campos con más de un valor que no son keywords, lanza la excepción, de lo contrario devuelve el documento pre-indexado.
            if (IndicesConVariosValores.Count > 0)
                throw new DWManagerManyValuesToIndexException(IndicesConVariosValores);

            return CreateDocumentIndexAndThrowExceptionWhenIndexNotFoundReturn;
        }
    }