Professional Applications Programmers/Consultants برمجة واستشارات تطبيقات الإنترنت
Skip Navigation LinksHome » Code Library » German

Public general use code classes and xml files that we've compiled and used over the years:

German class

   1:  using System;
   2:  using System.Xml.Linq;
   3:  using System.Linq;
   4:  using System.IO;
   5:  using System.Data;
   6:  using System.Collections;
   7:  using System.Collections.Generic;
   8:  using System.Reflection;
   9:   
  10:  namespace Ia.TentPlay.Cl.Model.Memorise
  11:  {
  12:      ////////////////////////////////////////////////////////////////////////////
  13:   
  14:      /// <summary publish="true">
  15:      /// German class
  16:      /// </summary>
  17:      /// <value>
  18:      /// https://msdn.microsoft.com/en-us/library/z1hkazw7(v=vs.100).aspx
  19:      /// </value>
  20:      /// <remarks> 
  21:      /// Copyright © 2008-2018 Jasem Y. Al-Shamlan (info@ia.com.kw), Internet Applications - Kuwait. All Rights Reserved.
  22:      ///
  23:      /// This library is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by
  24:      /// the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
  25:      ///
  26:      /// This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
  27:      /// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
  28:      /// 
  29:      /// You should have received a copy of the GNU General Public License along with this library. If not, see http://www.gnu.org/licenses.
  30:      /// 
  31:      /// Copyright notice: This notice may not be removed or altered from any source distribution.
  32:      /// </remarks> 
  33:      public class German : Test
  34:      {
  35:          private XDocument xDocument;
  36:          protected override TestTopic testTopic
  37:          {
  38:              get
  39:              {
  40:                  return Ia.TentPlay.Cl.Model.Memorise.Test.TestTopic.German;
  41:              }
  42:          }
  43:   
  44:          ////////////////////////////////////////////////////////////////////////////
  45:   
  46:          /// <summary>
  47:          ///
  48:          /// </summary>
  49:          public enum WordType { Verb = 1, Noun, Adjective, Adverb, Unspecified };
  50:   
  51:          ////////////////////////////////////////////////////////////////////////////
  52:   
  53:          /// <summary>
  54:          ///
  55:          /// </summary>
  56:          public struct Word
  57:          {
  58:              public WordType Type;
  59:              public string English;
  60:              public string German;
  61:   
  62:              /// <summary/>
  63:              public Word(string english, string german, WordType type)
  64:              {
  65:                  this.Type = type;
  66:                  this.English = english;
  67:                  this.German = german;
  68:              }
  69:   
  70:              /// <summary/>
  71:              public override string ToString()
  72:              {
  73:                  return this.German + ":" + this.English + ":" + this.Type;
  74:              }
  75:          }
  76:   
  77:          ////////////////////////////////////////////////////////////////////////////
  78:   
  79:          /// <summary>
  80:          ///
  81:          /// </summary>
  82:          public German() { }
  83:   
  84:          ////////////////////////////////////////////////////////////////////////////
  85:   
  86:          /// <summary>
  87:          ///
  88:          /// </summary>
  89:          public override void PopulateTestDatabaseTableWithInitialQuestionsIfEmpty(string userId)
  90:          {
  91:              int count;
  92:              string question, answer;
  93:              XDocument xDocument;
  94:              WordType wordType;
  95:              Ia.TentPlay.Cl.Model.Memorise.Score score;
  96:              List<Ia.TentPlay.Cl.Model.Memorise.Score> scoreList;
  97:   
  98:              xDocument = XDocument;
  99:   
 100:              // below: synch database words with XML list
 101:              using (var db = new Ia.TentPlay.Db.Memorise())
 102:              {
 103:                  count = (from s in db.Scores where s.TestId == (int)Ia.TentPlay.Cl.Model.Memorise.Test.TestTopic.German select s).Count();
 104:   
 105:                  if (count == 0)
 106:                  {
 107:                      scoreList = Ia.TentPlay.Cl.Model.Memorise.Score.GermanScoreList(userId);
 108:   
 109:                      foreach (XElement xe in xDocument.Elements("german").Elements())
 110:                      {
 111:                          switch (xe.Name.LocalName)
 112:                          {
 113:                              case "verb": wordType = WordType.Verb; break;
 114:                              case "noun": wordType = WordType.Noun; break;
 115:                              case "adjective": wordType = WordType.Adjective; break;
 116:                              case "adverb": wordType = WordType.Adverb; break;
 117:                              default: wordType = WordType.Unspecified; break;
 118:                          }
 119:   
 120:                          question = xe.Attribute("german").Value;
 121:                          answer = xe.Attribute("english").Value;
 122:   
 123:                          score = (from s in scoreList where s.TestId == (int)testTopic && s.Question == question && s.Answer == answer && s.TypeId == (int)wordType select s).FirstOrDefault();
 124:   
 125:                          if (score == null)
 126:                          {
 127:                              score = new Ia.TentPlay.Cl.Model.Memorise.Score();
 128:   
 129:                              score.Question = question;
 130:                              score.Answer = answer;
 131:                              score.TestId = (int)testTopic;
 132:                              score.TypeId = (int)wordType;
 133:                              score.Created = score.Updated = score.Viewed = DateTime.UtcNow.AddHours(3);
 134:                              //score.User.Id = identityUserId;
 135:   
 136:                              db.Scores.Add(score);
 137:                          }
 138:                      }
 139:   
 140:                      db.SaveChanges();
 141:                  }
 142:              }
 143:          }
 144:   
 145:          ////////////////////////////////////////////////////////////////////////////
 146:   
 147:          /// <summary>
 148:          ///
 149:          /// </summary>
 150:          public override int WeightedRandomTypeIdAccordingTypeDistribution(string userId)
 151:          {
 152:              int countOfAllTypes, countOfTypeId1, countOfTypeId2, countOfTypeId3, countOfTypeId4, countOfTypeId5, typeId;
 153:              ArrayList countArrayList;
 154:   
 155:              // public enum WordType { Verb = 1, Noun, Adjective, Adverb, Unspecified };
 156:   
 157:              using (var db = new Ia.TentPlay.Db.Memorise())
 158:              {
 159:                  countOfAllTypes = (from s in db.Scores where s.TestId == (int)testTopic select s).Count();
 160:                  countOfTypeId1 = (from s in db.Scores where s.TestId == (int)testTopic && s.TypeId == (int)WordType.Verb select s).Count();
 161:                  countOfTypeId2 = (from s in db.Scores where s.TestId == (int)testTopic && s.TypeId == (int)WordType.Noun select s).Count();
 162:                  countOfTypeId3 = (from s in db.Scores where s.TestId == (int)testTopic && s.TypeId == (int)WordType.Adjective select s).Count();
 163:                  countOfTypeId4 = (from s in db.Scores where s.TestId == (int)testTopic && s.TypeId == (int)WordType.Adverb select s).Count();
 164:                  countOfTypeId5 = (from s in db.Scores where s.TestId == (int)testTopic && s.TypeId == (int)WordType.Unspecified select s).Count();
 165:   
 166:                  countArrayList = new ArrayList(countOfAllTypes);
 167:   
 168:                  // below: populate ArrayList with TypeId keys a number of times equal to its count
 169:                  for (int i = 0; i < countOfTypeId1; i++) countArrayList.Add((int)WordType.Verb);
 170:                  for (int i = 0; i < countOfTypeId2; i++) countArrayList.Add((int)WordType.Noun);
 171:                  for (int i = 0; i < countOfTypeId3; i++) countArrayList.Add((int)WordType.Adjective);
 172:                  for (int i = 0; i < countOfTypeId4; i++) countArrayList.Add((int)WordType.Adverb);
 173:                  for (int i = 0; i < countOfTypeId5; i++) countArrayList.Add((int)WordType.Unspecified);
 174:   
 175:                  typeId = (int)countArrayList[random.Next(countOfAllTypes)];
 176:              }
 177:   
 178:              return typeId;
 179:          }
 180:   
 181:          /*
 182:          ////////////////////////////////////////////////////////////////////////////
 183:  
 184:          /// <summary>
 185:          /// 
 186:          /// </summary>        
 187:          [Obsolete("", true)]
 188:          public static void CheckAndMergeGermanXmlEntries()
 189:          {
 190:              StringBuilder sb;
 191:              Word final;
 192:              List<Word> firstList, middleList, tempList, lastList;
 193:  
 194:              firstList = ReadList();
 195:              middleList = ReadList();
 196:  
 197:              sb = new StringBuilder(firstList.Count * 100);
 198:  
 199:              tempList = new List<Word>(10);
 200:  
 201:  
 202:              // below: examine and handle exact (English, German, and type) redundant entries
 203:  
 204:              lastList = new List<Word>(firstList.Count);
 205:  
 206:              foreach (Word word in firstList)
 207:              {
 208:                  if (!lastList.Contains(word))
 209:                  {
 210:                      tempList = (from q in middleList where q.German == word.German && q.English == word.English && q.Type == word.Type select q).ToList<Word>();
 211:  
 212:                      if (tempList.Count > 0)
 213:                      {
 214:                          final = new Word();
 215:  
 216:                          final.German = word.German;
 217:                          final.English = word.English;
 218:                          final.Type = word.Type;
 219:  
 220:                          lastList.Add(final);
 221:  
 222:                          middleList.Remove(final);
 223:                      }
 224:                      else
 225:                      {
 226:                      }
 227:                  }
 228:              }
 229:  
 230:  
 231:              // below: examine and handle redundant (English, German) entries but keep the one with a word type
 232:  
 233:              firstList = lastList;
 234:              middleList.Clear();
 235:              lastList.ForEach(i => middleList.Add(i));
 236:  
 237:              lastList = new List<Word>(firstList.Count);
 238:  
 239:              foreach (Word word in firstList)
 240:              {
 241:                  if (!lastList.Contains(word))
 242:                  {
 243:                      tempList = (from q in middleList where q.German == word.German && q.English == word.English select q).ToList<Word>();
 244:  
 245:                      if (tempList.Count == 1 || tempList.Count == 2)
 246:                      {
 247:                          final = new Word();
 248:  
 249:                          final.German = word.German;
 250:                          final.English = word.English;
 251:  
 252:                          if (tempList.Count == 1)
 253:                          {
 254:                              final.Type = word.Type;
 255:                              lastList.Add(final);
 256:                              middleList.Remove(final);
 257:                          }
 258:                          else if (tempList.Count == 2)
 259:                          {
 260:                              if (tempList[0].Type != WordType.Unspecified && tempList[1].Type == WordType.Unspecified)
 261:                              {
 262:                                  final.Type = tempList[0].Type;
 263:                                  lastList.Add(final);
 264:  
 265:                                  middleList.Remove(tempList[0]);
 266:                                  middleList.Remove(tempList[1]);
 267:                              }
 268:                              else if (tempList[0].Type == WordType.Unspecified && tempList[1].Type != WordType.Unspecified)
 269:                              {
 270:                                  final.Type = tempList[1].Type;
 271:                                  lastList.Add(final);
 272:  
 273:                                  middleList.Remove(tempList[0]);
 274:                                  middleList.Remove(tempList[1]);
 275:                              }
 276:                              else
 277:                              {
 278:                                  // below: a word is both adverb and adjective
 279:                                  final.Type = tempList[0].Type;
 280:                                  lastList.Add(final);
 281:                                  middleList.Remove(final);
 282:  
 283:                                  final.Type = tempList[1].Type;
 284:                                  lastList.Add(final);
 285:                                  middleList.Remove(final);
 286:                              }
 287:                          }
 288:                      }
 289:                      else
 290:                      {
 291:                          // below: manually fix XML
 292:                      }
 293:                  }
 294:              }
 295:  
 296:  
 297:              // below: remove exact redundant entries (German only)
 298:  
 299:              firstList = lastList;
 300:              middleList.Clear();
 301:              lastList.ForEach(i => middleList.Add(i));
 302:  
 303:              lastList = new List<Word>(firstList.Count);
 304:  
 305:              foreach (Word word in firstList)
 306:              {
 307:                  if (!lastList.Contains(word))
 308:                  {
 309:                      tempList = (from q in middleList where q.German == word.German select q).ToList<Word>();
 310:  
 311:                      if (tempList.Count > 0)
 312:                      {
 313:                          if (tempList.Count == 1 || tempList.Count == 2)
 314:                          {
 315:                              final = new Word();
 316:  
 317:                              final.German = word.German;
 318:  
 319:                              if (tempList.Count == 1)
 320:                              {
 321:                                  final.Type = word.Type;
 322:                                  final.English = word.English;
 323:                                  lastList.Add(final);
 324:                                  middleList.Remove(final);
 325:                              }
 326:                              else if (tempList.Count == 2)
 327:                              {
 328:                                  if (tempList[0].English.Contains(tempList[1].English))
 329:                                  {
 330:                                      final.Type = tempList[0].Type;
 331:                                      final.English = tempList[0].English;
 332:                                      lastList.Add(final);
 333:  
 334:                                      middleList.Remove(tempList[0]);
 335:                                      middleList.Remove(tempList[1]);
 336:                                  }
 337:                                  else if (tempList[1].English.Contains(tempList[0].English))
 338:                                  {
 339:                                      final.Type = tempList[1].Type;
 340:                                      final.English = tempList[1].English;
 341:                                      lastList.Add(final);
 342:  
 343:                                      middleList.Remove(tempList[0]);
 344:                                      middleList.Remove(tempList[1]);
 345:                                  }
 346:                                  else
 347:                                  {
 348:                                      final.Type = tempList[0].Type;
 349:                                      final.English = tempList[0].English;
 350:                                      lastList.Add(final);
 351:                                      middleList.Remove(tempList[0]);
 352:  
 353:                                      final.Type = tempList[1].Type;
 354:                                      final.English = tempList[1].English;
 355:                                      lastList.Add(final);
 356:                                      middleList.Remove(tempList[1]);
 357:  
 358:                                      //sb.AppendLine(tempList[0].ToString());
 359:                                      //sb.AppendLine(tempList[1].ToString());
 360:                                  }
 361:                              }
 362:                          }
 363:                          else
 364:                          {
 365:                              // below: manually fix XML
 366:  
 367:                              sb.AppendLine(word.ToString());
 368:                          }
 369:                      }
 370:                  }
 371:              }
 372:  
 373:              // below: create new XML file
 374:              foreach (Word word in lastList)
 375:              {
 376:                  sb.AppendLine(@"<" + word.Type.ToString().ToLower() + @" german=""" + word.German + @""" english=""" + word.English + @"""/>");
 377:              }
 378:  
 379:          }
 380:          */
 381:   
 382:          ////////////////////////////////////////////////////////////////////////////
 383:          ////////////////////////////////////////////////////////////////////////////
 384:   
 385:          /// <summary>
 386:          /// 
 387:          /// How to embed and access resources by using Visual C# http://support.microsoft.com/kb/319292/en-us
 388:          /// 
 389:          /// 1. Change the "Build Action" property of your XML file from "Content" to "Embedded Resource".
 390:          /// 2. Add "using System.Reflection".
 391:          /// 3. See sample below.
 392:          /// 
 393:          /// </summary>
 394:          public XDocument XDocument
 395:          {
 396:              get
 397:              {
 398:                  if (xDocument == null)
 399:                  {
 400:                      Assembly _assembly;
 401:                      StreamReader streamReader;
 402:   
 403:                      _assembly = Assembly.GetExecutingAssembly();
 404:                      streamReader = new StreamReader(_assembly.GetManifestResourceStream("Ia.TentPlay.Cl.model.data.memorise.german.xml"));
 405:   
 406:                      try
 407:                      {
 408:                          if (streamReader.Peek() != -1)
 409:                          {
 410:                              xDocument = System.Xml.Linq.XDocument.Load(streamReader);
 411:                          }
 412:                      }
 413:                      catch (Exception)
 414:                      {
 415:                      }
 416:                      finally
 417:                      {
 418:                      }
 419:                  }
 420:   
 421:                  return xDocument;
 422:              }
 423:          }
 424:   
 425:          ////////////////////////////////////////////////////////////////////////////
 426:          ////////////////////////////////////////////////////////////////////////////    
 427:      }
 428:   
 429:      ////////////////////////////////////////////////////////////////////////////
 430:      ////////////////////////////////////////////////////////////////////////////   
 431:  }