Fasil Hayat's blog

...C#, .Net, Sharepoint, BizTalk, JQuery...

Say you have the need to flatten a collection of albums and retrieve all the photos within the albums and put them into a single album, you can use the SelectMany() notation in linq.

   1:  using System.Collections.Generic;
   2:      using System.IO;
   3:   
   4:      using System.Linq;
   5:   
   6:      class Program
   7:      {
   8:          static void Main(string[] args)
   9:          {
  10:              var data = GetAlbums();
  11:              var flattenAlbum = new Album { Id = 0, Name = "Flattenedalbum",  
  12:                  Photos = data.SelectMany(p => p.Photos).ToList() };
  13:          }
  14:   
  15:          private static IEnumerable<Album> GetAlbums()
  16:          {
  17:              var data = new List<Album>
  18:              {
  19:                  new Album
  20:                  {
  21:                      Id = 1, Name = "Album1", Photos = new List<Photo>
  22:                      {
  23:                          new Photo
  24:                          {
  25:                              Id = 1, Name = "Photo1"
  26:                          },
  27:                          new Photo
  28:                          {
  29:                              Id = 2, Name = "Photo2"
  30:                          },
  31:                          new Photo
  32:                          {
  33:                              Id = 3, Name = "Photo3"
  34:                          }
  35:                      }
  36:                  },
  37:                  new Album
  38:                  {
  39:                      Id = 2, Name = "Album2", Photos = new List<Photo>
  40:                      {
  41:                          new Photo
  42:                          {
  43:                              Id = 4, Name = "Photo4"
  44:                          },
  45:                          new Photo
  46:                          {
  47:                              Id = 5, Name = "Photo5"
  48:                          },
  49:                          new Photo
  50:                          {
  51:                              Id = 6, Name = "Photo6"
  52:                          },
  53:                          new Photo
  54:                          {
  55:                              Id = 7, Name = "Photo7"
  56:                          }
  57:                      }
  58:                  }
  59:              };
  60:              return data;
  61:          } 
  62:      }
  63:   
  64:      class Album
  65:      {
  66:          public int Id { get; set; }
  67:          public string Name { get; set; }
  68:          public List<Photo> Photos { get; set; }
  69:      }
  70:   
  71:      class Photo
  72:      {
  73:          public int Id { get; set; }
  74:          public string Name { get; set; }
  75:          public Stream Data { get; set; }
  76:      }


In addition to my previous post, where I was calculating age based on birthdates. If we go the other way around and pretend that we have an age span instead; an age 'from' and 'to' we can easily convert those to represent the datespan that we are interested in the following way.

public class Agespan
{
    public int AgeFrom { get; set; }
    public int AgeTo { get; set; }
 
    public DateTime DateFrom 
    {     get 
        { 
            { 
                return DateTime.Now.Date
                .AddYears(-AgeTo - 1)
                .AddDays(1); 
            }
        } 
    }
    public DateTime DateTo     
    { 
        get 
        { 
            return DateTime.Now.Date
            .AddYears(-AgeFrom)
            .AddHours(23)
            .AddMinutes(59)
            .AddSeconds(59); 
        } 
    }
}


Now we can in instantiate our "Agespan" object and use our dates on the object instead.

var agespan = new Agespan { AgeFrom = 24, AgeTo = 55 };


nov
17

Local variables with λ

af Fasil | Tags: ,

After a long pause I have decided to do all my future posts in English.

In a λ expression, I had a need to call an arbitrary method within my expression.
Now istead of calling the method multiple times within the expression, I had a need to assign the result to a local variable.

Here is the result of how that is achieved.

   1:  var result = mylist.AsEnumerable().Where(x => x 
   2:                      { 
   3:                          var age = GetAge(f.Birthdate); 
   4:                          return age >= search.Age.From && 
   5:                          age <= search.Age.To; 
   6:                      })
   7:                      ).Select(p => new Person 
   8:                          { 
   9:                              Id = p.Id,  
  10:                              Name = p.Name
  11:                          }).ToList();

 

Instead of invoking 'GetAge' method twice, the 'age' variable is declared and the result of the 'GetAge' is assigned to 'age'. The 'age' variable can now be used within the λ expression.



maj
18

JSON.net

af Fasil | Tags: , , ,

Efter en meget lang og sej kamp med den indbyggede json funktionalitet i .net, blev jeg nødt til at kaste håndklædet ved at gøre brug af json.net istedet. Dette lille json hjælpe bibliotek kunne uden problemer serialisere mine komplekse objekter til json.

string json = JsonConvert.SerializeObject(mitobjekt);
return json;

Læs mere her.


Jeg er ved at forelske mig lidt i Teleriks OpenAccess ORM som OR-mapper. For det første er den gratis, og så er den ret nem at bruge.

[Opdateret]
Telerik har noget af den mest irriterende og aggressive marketing strategi, hvor diverse køb af deres andre produkter popper op ved start af VS2010. Det kan være VS2010 har nogle problemer, men føj hvor er det belastende, at de ikke i det mindste har en checkbox, hvor man kan bede om ikke at blive notificeret / forstyrret yderligere. Telerik er hermed røget ned i bunden af mig efter efterfølgende brug.
Jeg vil nu hellere bruge Entity Framework 5. Telerik er streget væk fra min liste af brugbare tools. VÆK!

http://tv.telerik.com/products/orm



Til dynamisk indlæsning af konfigurationer, der er applikationsspecifikke, kan nedestående kode benyttes til at tilgå konfiguration for den enkelte applikation.
Et applikationskontekst bliver etableret og herigennem kan konfigurationsværdier tilgås. I dette tilfælde er almindelige konfigurationsværdier, sti for log4net og windsor konfiguration placeret i en enkel konfigurationsfil i en applikationsspecifik mappe.

Navnet på applikationen og mappen er en-til-en og indlæsning sker een gang for alle, og herefter kan singleton klassen tilgås på tværs af assemblies i den samme applikation.

   1:   /// <summary>
   2:   /// Applikationskontekst for applikationen.
   3:   /// </summary>
   4:   public sealed class ApplikationKontekst : Kontekst
   5:   {
   6:       /// <summary>
   7:       /// Lås på instans.
   8:       /// </summary>
   9:       private static readonly object SyncRoot = new object();
  10:   
  11:       /// <summary>
  12:       /// Instans af applikationskontekst.
  13:       /// </summary>
  14:       private static volatile ApplikationKontekst instans;
  15:   
  16:       /// <summary>
  17:       /// Instans af applikationskontekst.
  18:       /// </summary>
  19:       public static ApplikationKontekst Instans
  20:       {
  21:           get
  22:           {
  23:               lock (SyncRoot)
  24:               {
  25:                   return instans ?? (instans = new ApplikationKontekst
  26:                       {
  27:                           Navn = Assembly.GetCallingAssembly().GetName().Name
  28:                       });
  29:               }
  30:           }
  31:       }
  32:   
  33:       /// <summary>
  34:       /// Sætter nyt kontekst objekt op.
  35:       /// </summary>
  36:       public static void SetupKontekst()
  37:       {
  38:           Instans.Navn = Assembly.GetCallingAssembly().GetName().Name;
  39:       }
  40:   }


Kontekst klassen:

   1:   /// <summary>
   2:   /// Kontekst.
   3:   /// </summary>
   4:   public abstract class Kontekst
   5:   {
   6:       /// <summary>
   7:       /// Navn på assembly eller applikation.
   8:       /// </summary>
   9:       public string Navn { get; set; }
  10:   
  11:       /// <summary>
  12:       /// Konfigurationer fra konfigurationsstien.
  13:       /// </summary>
  14:       public Configuration Konfiguration
  15:       {
  16:           get
  17:           {
  18:               return KonfigurationProvider.HentKonfiguration(
  19:                   Konfigurationer.Default[FriendlyNavn(this.Navn)].ToString());
  20:           }
  21:       }
  22:   
  23:       /// <summary>
  24:       /// Fjerner evt. det fuld kvalificerede (Fully Qualified name)
  25:       ///  navn på assembly. Dvs. fjerner evt. namespaces.
  26:       /// </summary>
  27:       /// <param name="applikation">Navn på assembly.</param>
  28:       /// <returns>Det korte navn på assembly uden fuld namespace.</returns>
  29:       private static string FriendlyNavn(string applikation)
  30:       {
  31:           // Regexp udtryk søger bagfra i strengen, og fjerner alt fra '.'
  32:           // og nedefter. (dvs. fra højre mod venstre).
  33:           var regex = new Regex(@"(?<=\.)[^.]*$|^[^.]*$");
  34:           return regex.Match(applikation).Value;
  35:        }
  36:   }


Til indlæsning af konfigurationsfil:

   1:  public static class KonfigurationProvider
   2:  {
   3:      /// <summary>
   4:      /// Konfiguration objekt.
   5:      /// </summary>
   6:      private static Configuration konfiguration;
   7:   
   8:      /// <summary>
   9:      /// Henter konfiguration.
  10:      /// </summary>
  11:      /// <param name="konfigurationsfilSti"> The konfigurations Path. </param>
  12:      /// <returns> Konfigrationsobjekt i applikaitonshukommelse. </returns>
  13:      public static Configuration HentKonfiguration(string konfigurationsfilSti)
  14:      {
  15:          if (konfiguration != null)
  16:          {
  17:              return konfiguration;
  18:          }
  19:   
  20:          var filmap = new ExeConfigurationFileMap
  21:              {
  22:                  ExeConfigFilename = konfigurationsfilSti
  23:              };
  24:   
  25:          konfiguration = ConfigurationManager.OpenMappedExeConfiguration(
  26:              filmap, ConfigurationUserLevel.None);
  27:   
  28:          return konfiguration;
  29:      }
  30:  }


Værdierne tilgås herefter:

var a = ApplikationKontekst.Instans.Konfiguration.AppSettings.Settings["Windsor"].Value;
var b = ApplikationKontekst.Instans.Konfiguration.AppSettings.Settings["Log4Net"].Value;

Jeg er blevet spurtgt af flere, hvorfor der er behov for alt dette. Det korte svar er, at det kan være et alternativ til SSO i BizTalk.
Dog skal man være opmærksom, at denne måde at indlæse kræver at mappen, der holder på konfigurationerne ligger udenfor applikationen, hvilket ikke er oplagt i clustered miljøer.



Fasil Malik Hayat

Developer
.Net, WCF, Sharepoint, MOSS, Biztalk, JQuery.

linkedin facebook twitter plaxo google+ grooveshark boxee
fasil

Education

fasil

Bachelor of Science (Honours)
De Montfort University, Leicester.

Fag: Java, MVC, Information Strategy, ITIL

Microsoft Certified Technology Specialist

Skills

.net vs2010 - C# sharepoint sql server jquery ubuntu java netbeans


  

Sign in