Několik poznámek k přetypovávání generických kolekcí
Při práci s generickými kolekcemi asi každy občas zatouží převést generickou kolekci s objekty typu B na generickou kolekci s objekty typu A, přičemž instinktivně očekává, že když je typ A předkem typu B, žádný problém při konverzi nenastane a navíc půjde o konverzi implicitní - automatickou. Instinkty, intuice a další feminní rysy jsou ale při programování spíš zátěží (že by jeden z hlavních důvodů, proč je stále tak málo programátorek? ) 
)
Konkrétně - mějme tyto dvě třídy.
class Test
{
public override string ToString()
{
return "Test";
}
}
class SpecialTest : Test
{
public override string ToString()
{
return "SpecialTest";
}
}
Vytvoříme si kolekci (List) odvozených tříd SpecialTest.
List<SpecialTest> srcList = new List<SpecialTest> { new SpecialTest(), new SpecialTest() };
Při pokusu přetypovat List<SpecialTest> na kolekci objektů typu Test (List<Test>) neuspějeme.
List<Test> invalidAttemptList = srcList;
Cannot implicitly convert type 'System.Collections.Generic.List<CollectionInheritance.SpecialTest>' to 'System.Collections.Generic.List<CollectionInheritance.Test>'). Důvod je zřejmý - dva generické objekty List, jeden s generickým argumentem Test a druhý s generickým argumentem SpecialTest, jsou dvě zcela rozdílné a nezávislé třídy a skutečnost, že třída SpecialTest je potomkem třídy Test, neznamená, že by stejný vztah platil mezi třídami List<SpecialTest> a List<Test>. Autoři jazyka C# (dle svých vyjádření prozatím?) zavedli toto omezení kvůli typové bezpečnosti.
Možností, jak konverzi provést, je mnoho. Vyjmenujme alespoň ty, které nově přinesl LINQ.
LINQ nám nabízí pro daný účel metodu Cast, která zkonvertuje prvky ze zdrojové kolekce (IEnumerable) na (generický) typ předaný metodě.
IEnumerable<Test> ieList = srcList.Cast<Test>();
Jestliže by nebylo možné všechny prvky v kolekci převést na 'Test', bude vyvolána výjimka. Když máme v kolekci směs objektů z různých tříd nebo podporujících různá rozhraní, můžeme přetypovat pomocí dalšího standardního LINQ operátoru OfType, který do výsledné kolekce vloží jen ty objekty, které se pomocí operátoru as podaří přetypovat na cílový typ. Objekty, které přetypovat na cílový typ (v následujícím kódu tedy na typ Test) nelze, jsou ignorovány.
IEnumerable<Test> ieList2 = srcList.OfType<Test>();
Jestliže nechceme mít jako výslednou kolekci typ IEnumerable, můžeme použít další LINQ operátor ToList() a výsledek přetypování nám bude vrácen v instanci List<T>.
List<Test> testList = srcList.OfType<Test>().ToList();
Alternativou k předchozímu zápisu může být využití konstruktoru třídy List.
List<Test> testList2 = new List<Test>(srcList.OfType<Test>());
Jestliže nechcete vždy pracovat jen s kolekcí typu List a chcete přetypovávat například na typové kolekce, využijete mé extenzní metody.
Collection<Test> trgList = srcList.WideningConvert<SpecialTest, Test, Collection<Test>>();
Metodě WideningConvert předáte jako typové argumenty aktuální typ v generické kolekci (SpecialTest), cílový-výsledný typ, na který má být zdrojový typ převeden (Test) a typ kolekce, která má být vrácena. Kolekce musí mít bezparametrický konstruktor a také musí podporovat rozhraní ICollection<T>.
Pomocí extenzní metody lze přetypovávat i z kolekce objektů typu "předek" na kolekci "potomků".
Collection<SpecialTest> nextList = trgList.NarrowingConvert<Test, SpecialTest, Collection<SpecialTest>>();
Metoda WideningConvert svým názvem dává najevo, že je určena pro implicitní ("bezpečnou") konverzi, kdy převádíte kolekci potomků na kolekci předků. Obdobně, metoda NarrowingConvert přetypovává kolekci objektů typu "předek" na kolekci objektů typ "potomek (explicitni konverze). Metoda NarrowingConvert se pokusí převést každý objekt ve zdrojové kolekci na cílový typ ("Potomek") pomocí operátoru as. Jestliže přetypování selže, je zdrojový objekt ignorován, a proto může výsledná kolekce vrácená metodou NarrowingConvert obsahovat méně prvků než kolekce zdrojová.
Zde je kompletní výpis metod. Bylo by samozřejmě možné začít uvažovat nad zjednodušením kódu pro přetypovávání, ale to si necháme "napříště".
public static class ConvertExtensions
{
/// <summary>
/// Metoda převede kolekci - metoda je určena pro přetypování generické kolekce s "potomky" na generickou kolekci s "předkem"
/// </summary>
/// <typeparam name="T0">Typ elementu v zdrojové kolekci</typeparam>
/// <typeparam name="P">Typ elementu v cílové kolekci</typeparam>
/// <typeparam name="R">Typ cílové kolekce</typeparam>
/// <param name="source">Zdrojová kolekce</param>
/// <returns>Cílovou kolekci s převedenými elementy</returns>
public static R WideningConvert<T0, P, R>(this IEnumerable<T0> source)
where R : ICollection<P>, new()
where T0: P
{
if (source == null)
{
throw new ArgumentNullException();
}
R retCol = new R();
foreach (T0 srcElem in source)
{
retCol.Add(srcElem);
}
return retCol;
}
/// <summary>
/// Metoda převede kolekci - metoda je určena pro přetypování generické kolekce s "předkem" na generickou kolekci "potomků"
/// </summary>
/// <typeparam name="T0">Typ elementu v zdrojové kolekci</typeparam>
/// <typeparam name="P">Typ elementu v cílové kolekci</typeparam>
/// <typeparam name="R">Typ cílové kolekce</typeparam>
/// <param name="source">Zdrojová kolekce</param>
/// <returns>Cílovou kolekci s převedenými elementy</returns>
///<remarks>Počet prvků v cílové kolekcí může být menší než počet prvků v zdrojové kolekci, protože veškeré objekty, které nelze zkonvertovat na <typeparamref name="R"/>, jsou ignorovány</remarks>
public static R NarrowingConvert<T0, P, R>(this IEnumerable<T0> source)
where R : ICollection<P>, new()
where P : class, T0
{
if (source == null)
{
throw new ArgumentNullException();
}
R retCol = new R();
foreach (T0 srcElem in source)
{
P retValue = srcElem as P;
if (retValue != null)
{
retCol.Add(retValue);
}
}
return retCol;
}
}
Monday, 15 September 2008 13:29:48 (Central Europe Standard Time, UTC+01:00)
.NET Framework | Compact .Net Framework | LINQ