Q:

EF Code First multi language support

Assuming you have to develop a website supporting multiple languages with EF Code First and POCO classes how would you model your POCO classes to support this scenario? 
By multi-language support I meant not only having e.g. labels translation in some resource files for your UI, but also you'd need to store Name, Description, etc for a given domain entity in your database. 
E.g.: Let's say your Domain model has an entity Product.  In your database you need to store the Product' Name & Description (2 fields for simplicity) for 2 languages(but more languages can be added in the future). 
Based on the current culture, the UI needs to pick up the labels' text from the resource files(this is easy to implement) but you also need to display the Product' Name & Description that comes from the database. 

A:

Finally I have made my own classes to support multilingual in my database data. 
I'm Spanish and I have translated my code for post here, Maybe it have simple syntax errors,  

You have a Product class that have a ProductName property as a MultilingualString type
MultilingualString class have a default text for every unknown language and have a list of translations of this text.  It have methods for set the different translations (SetTranslation) and methods to translate to specific language.  By the end this class have a property tu translate to the current thread culture (Translation)
You have the Translation class which have the language and the translated text

Here the code:
public class Product
{
    public int Id { get; set; }
    public MultilingualString ProductName { get; set; }
}

public class MultilingualString
{
    // You need it only to make the class persistent
    public int Id { get; set; }

    public string Text { get; set; }
    public virtual ICollection<Translation> Translations { get; set; }

    public string Translation { get { return Translate(); } }

    public void SetTranslation(string language, string text)
    {
        if (Translations == null)
            Translations = new List<Translation>();

        var found = Translations. Where(t => t.Language. ToUpper() == language. ToUpper()).FirstOrDefault();
        if (found == null)
            Translations. Add(new Translation() { Language = language, Text = text });
        else
            found. Text = text;
    }

    public string Translate(string cultureName)
    {
        return Translate(new CultureInfo(cultureName));
    }

    public string Translate(CultureInfo culture = null)
    {
        if (culture == null)
            culture = Thread. CurrentThread. CurrentCulture;

        var translation = Translations == null
                             ?  null
                             : Translations. Where(
                                 t =>
                                 culture. Name. ToUpper(CultureInfo. InvariantCulture).StartsWith(
                                     t.Language. ToUpper(CultureInfo. InvariantCulture))).FirstOrDefault();

        return translation == null ?  Text : translation. Text;
    }
}

public class Translation
{
    // You need it only to make the class persistent
    public int Id { get; set; }
    public string Language { get; set; }
    public string Text { get; set; }
}

You can build the DbContext class and make some test like this:
public class MultilingualContext : DbContext
{
    public DbSet<Product> Products { get; set; }
}

[TestClass]
public class Tests
{
    [TestMethod]
    public void ThisWorksFine()
    {
        using (var context = new MultilingualContext())
        {
            var product = new Product();
            context. Products. Add(product);

            product. ProductName = new MultilingualString() { Text = "Beer (default language)" };
            product. ProductName. SetTranslation("en", "Beer");
            product. ProductName. SetTranslation("es", "Cerveza");
            product. ProductName. SetTranslation("fr", "Bière");
            product. ProductName. SetTranslation("de", "Bier");

            var spanishProductName = product. ProductName. Translate(new CultureInfo("es"));
            Assert. AreEqual(spanishProductName, "Cerveza");

            var culture = Thread. CurrentThread. CurrentCulture;

            Thread. CurrentThread. CurrentCulture = new CultureInfo("en");
            Assert. AreEqual(product. ProductName. Translation, "Beer");
            Thread. CurrentThread. CurrentCulture = new CultureInfo("es");
            Assert. AreEqual(product. ProductName. Translation, "Cerveza");
            Thread. CurrentThread. CurrentCulture = new CultureInfo("fr");
            Assert. AreEqual(product. ProductName. Translation, "Bière");
            Thread. CurrentThread. CurrentCulture = new CultureInfo("de");
            Assert. AreEqual(product. ProductName. Translation, "Bier");
            Thread. CurrentThread. CurrentCulture = new CultureInfo("it");
            Assert. AreEqual(product. ProductName. Translation, "Beer (default language)");

            Thread. CurrentThread. CurrentCulture = culture;

            context. SaveChanges();

        }
    }
}

I have just to end it, I hope this works fine ;)
Best regards! 
UPDATE
One more thing, when you remove the product don't remove the multilingual string entry.  You can add bussines logical to your services and remove the multilingual entry when you remove the product. 
Or not!.  if you don't remove the multilingual entry you will have more and more MultilingualStrings entries and you could take advantage of this repository to offer translated products names for the future products. 
You can add MultilingualStrings set to the context:
public class MultilingualContext : DbContext
{
    public DbSet<Product> Products { get; set; }
    public DbSet<MultilingualString> MultilingualStrings { get; set; }
}

Then you can search MultilingualStrings in the ProductNameTextBoxOnChange event for example:
context. MultilingualStrings. Where(s => s.Translation. StartsWith(ProductNameTextBox. Text));

And you can using this repository for other properties of other entities that have multilingual strings.