C# CsvReader.TryGetField方法代码示例

        public void TryGetFieldIndexTest()
        {
            var parserMock = new ParserMock
            {
                { "One", "Two", "Two" },
                { "1", "2", "3" }
            };
            var reader = new CsvReader( parserMock );
            reader.Read();

            int field;
            var got = reader.TryGetField( "Two", 0, out field );
            Assert.IsTrue( got );
            Assert.AreEqual( 2, field );

            got = reader.TryGetField( "Two", 1, out field );
            Assert.IsTrue( got );
            Assert.AreEqual( 3, field );
        }

        public void TryGetDoesNotThrowWhenWillThrowOnMissingFieldIsEnabled()
        {
            var data = new[] { "1" };
            var queue = new Queue<string[]>();
            queue.Enqueue( data );
            queue.Enqueue( null );
            var parserMock = new ParserMock( queue );

            var reader = new CsvReader( parserMock );
            reader.Configuration.WillThrowOnMissingField = true;
            reader.Read();
            string field;
            Assert.IsFalse( reader.TryGetField( "test", out field ) );
        }

		public void TryGetFieldInvalidNameTest()
		{
			var data1 = new[] { "One", "Two" };
			var data2 = new[] { "one", "two" };
			var queue = new Queue<string[]>();
			queue.Enqueue( data1 );
			queue.Enqueue( data2 );
			queue.Enqueue( null );
			var parserMock = new ParserMock( queue );

			var reader = new CsvReader( parserMock );
			reader.Read();

			int field;
			var got = reader.TryGetField( "One", out field );
			Assert.IsFalse( got );
			Assert.AreEqual( default( int ), field );
		}

		public void TryGetFieldTest()
		{
			var data1 = new[] { "One", "Two" };
			var data2 = new[] { "1", "2" };
			var queue = new Queue<string[]>();
			queue.Enqueue( data1 );
			queue.Enqueue( data2 );
			queue.Enqueue( null );
			var parserMock = new ParserMock( queue );

			var reader = new CsvReader( parserMock );
			reader.Read();

			int field;
			var got = reader.TryGetField( 0, out field );
			Assert.IsTrue( got );
			Assert.AreEqual( 1, field );
		}

        public void TryGetFieldEmptyDate()
        {
            // DateTimeConverter.IsValid() doesn't work correctly
            // so we need to test and make sure that the conversion
            // fails for an emptry string for a date.
            var data = new[] { " " };
            var queue = new Queue<string[]>();
            queue.Enqueue( data );
            queue.Enqueue( null );
            var parserMock = new ParserMock( queue );

            var reader = new CsvReader( parserMock );
            reader.Configuration.HasHeaderRecord = false;
            reader.Read();

            DateTime field;
            var got = reader.TryGetField( 0, out field );

            Assert.IsFalse( got );
            Assert.AreEqual( DateTime.MinValue, field );
        }

        private void button2_Click(object sender, EventArgs e)
        {
            string fieldName = ConfigurationManager.AppSettings["csvFieldName"];
            XElement root = new XElement("pdfFields");
            using(var sr = new System.IO.StreamReader(openFileDialog1.FileName))
            {
                var csv = new CsvReader(sr);
                csv.Configuration.Delimiter = ";";
                while (csv.Read())
                {
                    string mapValue = null;
                    
                    csv.TryGetField<string>(fieldName, out mapValue);
                    if (!string.IsNullOrEmpty(mapValue))
                    {
                        var elem = new XElement("pdfField");
                        elem.Add(new XAttribute("originalValue" , mapValue));
                        elem.Add(new XAttribute("mapValue" , mapValue));
                        root.Add(elem); 
                    }
                }
            }
            var saveres = saveFileDialog1.ShowDialog();
            if (saveres == System.Windows.Forms.DialogResult.OK)
            {
                XDocument doc = new XDocument();
                doc.Add(root);
                try
                {
                    doc.Save(saveFileDialog1.FileName);
                    label2.Text = label2.Text + Environment.NewLine +"File " + saveFileDialog1.FileName + " was successfully saved.";
                }
                catch(Exception ex)
                {
                    label2.Text = label2.Text + Environment.NewLine + ex.Message;
                }
            }

        }

        public void TryGetFieldStrictTest()
        {
            var data1 = new[] { "One", "Two" };
            var data2 = new[] { "1", "2" };
            var queue = new Queue<string[]>();
            queue.Enqueue( data1 );
            queue.Enqueue( data2 );
            queue.Enqueue( null );
            var parserMock = new ParserMock( queue );

            var reader = new CsvReader( parserMock ) { Configuration = { WillThrowOnMissingField = true } };
            reader.Read();

            int field;
            var got = reader.TryGetField( "One", out field );
            Assert.IsTrue( got );
            Assert.AreEqual( 1, field );
        }

        public void TryGetFieldTest()
        {
            var isHeaderRecord = true;
            var data1 = new[] { "One", "Two" };
            var data2 = new[] { "1", "2" };
            var mockFactory = new MockRepository( MockBehavior.Default );
            var parserMock = mockFactory.Create<ICsvParser>();
            parserMock.Setup( m => m.Configuration ).Returns( new CsvConfiguration() );
            parserMock.Setup( m => m.Read() ).Returns( () =>
            {
                if( isHeaderRecord )
                {
                    isHeaderRecord = false;
                    return data1;
                }
                return data2;
            } );

            var reader = new CsvReader( parserMock.Object );
            reader.Read();

            int field;
            var got = reader.TryGetField( 0, out field );
            Assert.True( got );
            Assert.Equal( 1, field );
        }

        public void TryGetFieldEmptyDate()
        {
            // DateTimeConverter.IsValid() doesn't work correctly
            // so we need to test and make sure that the conversion
            // fails for an emptry string for a date.
            var data = new[] { " " };

            var mockFactory = new MockRepository( MockBehavior.Default );

            var parserMock = mockFactory.Create<ICsvParser>();
            parserMock.Setup( m => m.Configuration ).Returns( new CsvConfiguration() );
            parserMock.Setup( m => m.Read() ).Returns( data );

            var reader = new CsvReader( parserMock.Object );
            reader.Read();

            DateTime field;
            var got = reader.TryGetField( 0, out field );

            Assert.False( got );
            Assert.Equal( DateTime.MinValue, field );
        }

        private static string[,] ReadCSVFile(string inputFile)
        {
            try
            {
                IList<string> errors = new List<string>();
                IList<string> validTimeRecord = new List<string>();
                IList<string> validValueRecord = new List<string>();
                bool hasHeaders = HasHeaders(inputFile);
                using (TextReader reader = File.OpenText(inputFile))
                {

                    var csv = new CsvReader(reader);
                    if(hasHeaders)
                    {
                        csv.Configuration.HasHeaderRecord = true;
                    }
                    while (csv.Read())
                    {
                        try
                        {

                            var time = csv.GetField<DateTime>(0);
                            bool validRow = false;
                            DateTime timeField;
                            if (csv.TryGetField(0, out timeField))
                            {
                                double valueField;
                                if (csv.TryGetField(1, out valueField))
                                {
                                    validRow = true;
                                    validTimeRecord.Add(timeField.ToString("s"));
                                    validValueRecord.Add(valueField.ToString());
                                }

                            }

                            if(!validRow)
                            {
                                errors.Add(csv.Row.ToString());
                            }

                        }catch(Exception yx)
                        {
                            Log.ErrorFormat("Error parsing CSV field. Omitting field. {0}", yx);
                        }
                    }//while

                   if(errors.Count > 0)
                    {
                        File.WriteAllLines("badrecords.log", errors.ToArray());
                    }

                    int MAX_COUNT = validTimeRecord.Count;
                    string[,] bigArr = new string[MAX_COUNT, 2];
                    for (int i = 0; i < MAX_COUNT; i++)
                    {
                        bigArr[i, 0] = validTimeRecord[i];
                        bigArr[i, 1] = validValueRecord[i];

                    }

                    return bigArr;

                }

            }catch(Exception ex)
            {
                Log.FatalFormat("Error while reading csv file {0}.", ex.Message);

                throw ex;
            }
        }

        public void TryGetFieldStrictTest()
        {
            var isHeaderRecord = true;
            var data1 = new[] { "One", "Two" };
            var data2 = new[] { "1", "2" };
            var mockFactory = new MockFactory( MockBehavior.Default );
            var parserMock = mockFactory.Create<ICsvParser>();
            parserMock.Setup( m => m.Read() ).Returns( () =>
            {
                if( isHeaderRecord )
                {
                    isHeaderRecord = false;
                    return data1;
                }
                return data2;
            } );

            var reader = new CsvReader( parserMock.Object, new CsvReaderOptions { Strict = true } );
            reader.Read();

            int field;
            var got = reader.TryGetField( "One", out field );
            Assert.IsTrue( got );
            Assert.AreEqual( 1, field );
        }

        public void TryGetFieldInvalidTest()
        {
            var isHeaderRecord = true;
            var data1 = new[] { "One", "Two" };
            var data2 = new[] { "1", "2" };
            var mockFactory = new MockFactory( MockBehavior.Default );
            var parserMock = mockFactory.Create<ICsvParser>();
            parserMock.Setup( m => m.Read() ).Returns( () =>
            {
                if( isHeaderRecord )
                {
                    isHeaderRecord = false;
                    return data1;
                }
                return data2;
            } );

            var reader = new CsvReader( parserMock.Object );
            reader.Read();

            string field;
            var got = reader.TryGetField( -1, out field );
            Assert.IsFalse( got );
            Assert.IsNull( field );
        }

        private bool importArticles(string filepath, Interfaces.IDatabase database)
        {
            using (System.IO.TextReader textreader = System.IO.File.OpenText(filepath))
            {
                var csv = new CsvReader(textreader);
                csv.Configuration.Delimiter = ";";

                var taskedUnits = database.ArticleUnits();
                var unitlist = taskedUnits.Result;

                var output = new List<Core.Articles.Article>();

                while (csv.Read())
                {
                    string ID;
                    if (!csv.TryGetField("Artikelnummer", out ID))
                    {
                        var task = database.GetNextArticleID();
                        ID = (task.Result).ToString();
                    }

                    string description;
                    if (!csv.TryGetField("Bezeichnung", out description))
                    {
                        description = "" ;
                    }

                    string text;
                    if (!csv.TryGetField("Text", out text))
                    {
                        text = "";
                    }

                    string unit;
                    if (!csv.TryGetField("Einheit", out unit))
                    {
                        unit = "";
                    }

                    string price1;
                    if (!csv.TryGetField("Preis 1", out price1))
                    {
                        price1 = "";
                    }

                    string tax;
                    if (!csv.TryGetField("Steuersatz", out tax))
                    {
                        tax = "";
                    }

                    var article = new Articles.Article();
                    article.ArticleID = ID;
                    article.ArticleDescription = description;
                    article.ArticleText = text;
                    article.Price1.Price1.AmountString = price1;

                    var list = from units in unitlist where units.ShortName.ToLower().Contains(unit.ToLower()) select units;
                    if (list.Count() > 0)
                        article.ArticleUnit = list.First();

                    //var saveresult = database.SaveOrUpdateArticle(article);
                    //if (!saveresult.Result)
                    //    database.SaveOrUpdateArticle(article);

                    output.Add(article);
                }
                database.SaveOrUpdateArticle(output);
            }
            return true;
        }