EF 6: Un ejemplo de pluralizador en castellano

Desde hace ya un tiempo vengo recibiendo bastantes correos con respecto a una de las nuevas características de EF 6 referida al sistema de pluralización. Aunque ya en este mismo blog he hablado un poco sobre esta característica la verdad es que no había enseñado un ejemplo completo. Por eso, intentaré publicar en este blog ejemplos completos sobre algunas piezas de las que hemos hablado en EF 6 pero de las que no hemos dado ejemplo completos, para este y para los siguientes posts, el código lo puede descargar desde GitHub:

https://github.com/unaizorrilla/ef.contrib.git

Para la creación del sistema de pluralización en castellano intenté no reinventar la rueda y ver como otros hacían este trabajo, como por ejemplo Andrew Peters. @anpete – developer de ADO.NET EF, con su Inflector .NET. Para las reglas de pluralización en castellano uno puede ver los diferentes documentos que hay en internet sobre esto, basta abrir Bing y hacer una pequeña búsqueda para ver cantidad de enlaces. Después de leer sobre estas reglas un posible esbozo del pluralizador podría ser el siguiente, por supuesto el código tiene sus correspondientes tests que si os interesa podríais ayudar a mejorar incluyendo nuevos casos de prueba, tanto para los elementos irregulares como para los regulares.

    <span class="rem">/// &lt;summary&gt;</span>
    <span class="rem">///  Pluralization service for spanish language.</span>
    <span class="rem">/// &lt;/summary&gt;</span>
    <span class="kwrd">public</span> <span class="kwrd">class</span> SpanishPluralizationService
        :IPluralizationService
    {
        BidirectionalDictionary&lt;String, String&gt; _userDictionaryEntries = <span class="kwrd">new</span> BidirectionalDictionary&lt;String, String&gt;();

        StringBidirectionalDictionary _irregularWords = <span class="kwrd">new</span> StringBidirectionalDictionary(<span class="kwrd">new</span> Dictionary&lt;<span class="kwrd">string</span>, <span class="kwrd">string</span>&gt;()
        {
            {<span class="str">"faralá"</span>,<span class="str">"faralaes"</span>},
            {<span class="str">"albalá"</span>,<span class="str">"albalaes"</span>},
            {<span class="str">"no"</span>,<span class="str">"noes"</span>},
            {<span class="str">"gay"</span>,<span class="str">"gais"</span>},
            {<span class="str">"jersey"</span>,<span class="str">"jerséis"</span>},
            {<span class="str">"espray"</span>,<span class="str">"espráis"</span>},
            {<span class="str">"yóquey"</span>,<span class="str">"yoqueis"</span>},
            {<span class="str">"gachí"</span>,<span class="str">"gachís"</span>},
            {<span class="str">"pirulí"</span>,<span class="str">"pirulís"</span>},
            {<span class="str">"popurrí"</span>,<span class="str">"popurrís"</span>},
            {<span class="str">"champú"</span>,<span class="str">"champús"</span>},
            {<span class="str">"menú"</span>,<span class="str">"menús"</span>},
            {<span class="str">"tutú"</span>,<span class="str">"tutús"</span>},
            {<span class="str">"vermú"</span>,<span class="str">"vermús"</span>},
            {<span class="str">"lunes"</span>,<span class="str">"lunes"</span>},
            {<span class="str">"martes"</span>,<span class="str">"martes"</span>},
            {<span class="str">"miércoles"</span>,<span class="str">"miércoles"</span>},
            {<span class="str">"jueves"</span>,<span class="str">"jueves"</span>},
            {<span class="str">"viernes"</span>,<span class="str">"viernes"</span>},
            {<span class="str">"cienpiés"</span>,<span class="str">"cienpiés"</span>},
            {<span class="str">"buscapiés"</span>,<span class="str">"buscapiés"</span>},
            {<span class="str">"pasarurés"</span>,<span class="str">"pasapurés"</span>},
            {<span class="str">"polisíndeton"</span>,<span class="str">"polisíndeton"</span>},
            {<span class="str">"trávelin"</span>,<span class="str">"trávelin"</span>},
            {<span class="str">"cátering"</span>,<span class="str">"cátering"</span>},
            {<span class="str">"hipérbaton"</span>,<span class="str">"hipérbatos"</span>},
            {<span class="str">"imán"</span>,<span class="str">"imanes"</span>},
            {<span class="str">"imam"</span>,<span class="str">"imames"</span>},
            {<span class="str">"álbum"</span>,<span class="str">"álbumes"</span>},
            {<span class="str">"sándwich"</span>,<span class="str">"sandwiches"</span>},
            {<span class="str">"paraguas"</span>,<span class="str">"paraguas"</span>},
            {<span class="str">"tijeras"</span>,<span class="str">"tijeras"</span>},
            {<span class="str">"gafas"</span>,<span class="str">"gafas"</span>},
            {<span class="str">"víveres"</span>,<span class="str">"víveres"</span>},
            {<span class="str">"virus"</span>,<span class="str">"virus"</span>},
            {<span class="str">"atlas"</span>,<span class="str">"atlas"</span>},
            {<span class="str">"déficit"</span>,<span class="str">"déficit"</span>},
            {<span class="str">"crisis"</span>,<span class="str">"crisis"</span>},
            {<span class="str">"tórax"</span>,<span class="str">"tórax"</span>},
            {<span class="str">"fórceps"</span>,<span class="str">"fórceps"</span>},
            {<span class="str">"ratio"</span>,<span class="str">"ratios"</span>},
            {<span class="str">"plus"</span>,<span class="str">"pluses"</span>},
            {<span class="str">"tos"</span>,<span class="str">"toses"</span>},
            {<span class="str">"lapsus"</span>,<span class="str">"lapsus"</span>},
            {<span class="str">"ultimátum"</span>, <span class="str">"ultimatos"</span>},
            {<span class="str">"memorándum"</span>, <span class="str">"memorandos"</span>},
            {<span class="str">"referéndum"</span>, <span class="str">"referendos"</span>},
            {<span class="str">"vals"</span>,<span class="str">"valses"</span>}
        });

        <span class="kwrd">private</span> <span class="kwrd">readonly</span> List&lt;ReplacementRule&gt; PluralizationRules =
            <span class="kwrd">new</span> List&lt;ReplacementRule&gt;();

        <span class="kwrd">private</span> <span class="kwrd">readonly</span> List&lt;ReplacementRule&gt; SingularizationRules =
            <span class="kwrd">new</span> List&lt;ReplacementRule&gt;();

        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">/// Create a new instance</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="rem">/// &lt;param name="userDictionaryEntries"&gt;&lt;/param&gt;</span>
        <span class="kwrd">public</span> SpanishPluralizationService(IEnumerable&lt;CustomPluralizationEntry&gt; userDictionaryEntries)
            : <span class="kwrd">this</span>()
        {
            userDictionaryEntries.Each(entry =&gt;
            {
                _userDictionaryEntries.AddValue(entry.Singular, entry.Plural);
            });
        }

        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">/// Create a new instance</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="kwrd">public</span> SpanishPluralizationService()
        {
            <span class="rem">//Add pluralization rules</span>
            PluralizationRules.Add(<span class="kwrd">new</span> ReplacementRule(<span class="str">"([aeiouáéó])$"</span>, <span class="str">"$1s"</span>));
            PluralizationRules.Add(<span class="kwrd">new</span> ReplacementRule(<span class="str">"([íú])$"</span>, <span class="str">"$1es"</span>));
            PluralizationRules.Add(<span class="kwrd">new</span> ReplacementRule(<span class="str">"([aeiou]+y$)"</span>, <span class="str">"$1es"</span>));
            PluralizationRules.Add(<span class="kwrd">new</span> ReplacementRule(<span class="str">"([b-df-hj-np-tv-z]+)y$"</span>, <span class="str">"$1is"</span>));
            PluralizationRules.Add(<span class="kwrd">new</span> ReplacementRule(<span class="str">"([a-z]+)ás$"</span>, <span class="str">"$1ases"</span>));
            PluralizationRules.Add(<span class="kwrd">new</span> ReplacementRule(<span class="str">"([a-z]+)és$"</span>, <span class="str">"$1eses"</span>));
            PluralizationRules.Add(<span class="kwrd">new</span> ReplacementRule(<span class="str">"([a-z]+)ís$"</span>, <span class="str">"$1ises"</span>));
            PluralizationRules.Add(<span class="kwrd">new</span> ReplacementRule(<span class="str">"([a-z]+)ós$"</span>, <span class="str">"$1oses"</span>));
            PluralizationRules.Add(<span class="kwrd">new</span> ReplacementRule(<span class="str">"([a-z]+)ús$"</span>, <span class="str">"$1uses"</span>));
            PluralizationRules.Add(<span class="kwrd">new</span> ReplacementRule(<span class="str">"([a-z]+)s$"</span>, <span class="str">"$1ses"</span>));
            PluralizationRules.Add(<span class="kwrd">new</span> ReplacementRule(<span class="str">"([aeiou]+)[l]$"</span>, <span class="str">"$1les"</span>));
            PluralizationRules.Add(<span class="kwrd">new</span> ReplacementRule(<span class="str">"([aeiou]+)[r]$"</span>, <span class="str">"$1res"</span>));
            PluralizationRules.Add(<span class="kwrd">new</span> ReplacementRule(<span class="str">"([aeiou]+)[n]$"</span>, <span class="str">"$1nes"</span>));
            PluralizationRules.Add(<span class="kwrd">new</span> ReplacementRule(<span class="str">"([aeiou]+)[d]$"</span>, <span class="str">"$1des"</span>));
            PluralizationRules.Add(<span class="kwrd">new</span> ReplacementRule(<span class="str">"([aeiou]+)[z]$"</span>, <span class="str">"$1zes"</span>));
            PluralizationRules.Add(<span class="kwrd">new</span> ReplacementRule(<span class="str">"([aeiou]+)[j]$"</span>, <span class="str">"$1jes"</span>));
            PluralizationRules.Add(<span class="kwrd">new</span> ReplacementRule(<span class="str">"([a-z]+)ch$"</span>, <span class="kwrd">null</span>));
            PluralizationRules.Add(<span class="kwrd">new</span> ReplacementRule(<span class="str">"(ng|[mwckgtp])$"</span>, <span class="str">"$1s"</span>));

            <span class="rem">//Add singularization rules</span>
            SingularizationRules.Add(<span class="kwrd">new</span> ReplacementRule(<span class="str">"([ghñpv]e)s$"</span>, <span class="str">""</span>));
            SingularizationRules.Add(<span class="kwrd">new</span> ReplacementRule(<span class="str">"([bcdfghjklmnñprstvwxyz]{2,}e)s$"</span>, <span class="str">"$1"</span>));
            SingularizationRules.Add(<span class="kwrd">new</span> ReplacementRule(<span class="str">"([^e])s$"</span>, <span class="str">"$1"</span>));
            SingularizationRules.Add(<span class="kwrd">new</span> ReplacementRule(<span class="str">"(oides)$"</span>, <span class="str">"oide"</span>));
            SingularizationRules.Add(<span class="kwrd">new</span> ReplacementRule(<span class="str">"(é)s$"</span>, <span class="str">"$1"</span>));
            SingularizationRules.Add(<span class="kwrd">new</span> ReplacementRule(<span class="str">"(sis|tis|xis)+$"</span>, <span class="str">"$1"</span>));
            SingularizationRules.Add(<span class="kwrd">new</span> ReplacementRule(<span class="str">"(ces)$"</span>, <span class="str">"z"</span>));
            SingularizationRules.Add(<span class="kwrd">new</span> ReplacementRule(<span class="str">"^([bcdfghjklmnñpqrstvwxyz]*)([aeiou])([ns])es$"</span>, <span class="str">"$1$2$3"</span>));
            SingularizationRules.Add(<span class="kwrd">new</span> ReplacementRule(<span class="str">"es$"</span>, <span class="str">""</span>));
        }

       
        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">/// &lt;see cref="System.Data.Entity.Infrastructure.Pluralization.IPluralizationService"/&gt;</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="rem">/// &lt;param name="word"&gt;&lt;see cref="System.Data.Entity.Infrastructure.Pluralization.IPluralizationService"/&gt;&lt;/param&gt;</span>
        <span class="rem">/// &lt;returns&gt;&lt;see cref="System.Data.Entity.Infrastructure.Pluralization.IPluralizationService"/&gt;&lt;/returns&gt;</span>
        <span class="kwrd">public</span> <span class="kwrd">string</span> Pluralize(<span class="kwrd">string</span> word)
        {
            <span class="kwrd">return</span> Capitalize(word, InternalPluralize);
        }
        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">/// &lt;see cref="System.Data.Entity.Infrastructure.Pluralization.IPluralizationService"/&gt;</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="rem">/// &lt;param name="word"&gt;&lt;see cref="System.Data.Entity.Infrastructure.Pluralization.IPluralizationService"/&gt;&lt;/param&gt;</span>
        <span class="rem">/// &lt;returns&gt;&lt;see cref="System.Data.Entity.Infrastructure.Pluralization.IPluralizationService"/&gt;&lt;/returns&gt;</span>
        <span class="kwrd">public</span> <span class="kwrd">string</span> Singularize(<span class="kwrd">string</span> word)
        {
            <span class="kwrd">return</span> Capitalize(word, InternalSingularize);
        }

        <span class="kwrd">string</span> InternalSingularize(<span class="kwrd">string</span> word)
        {
            <span class="kwrd">if</span> (_userDictionaryEntries.ExistsInSecond(word))
                <span class="kwrd">return</span> _userDictionaryEntries.GetFirstValue(word);

            <span class="kwrd">if</span> (_irregularWords.ExistsInSecond(word))
                <span class="kwrd">return</span> _irregularWords.GetFirstValue(word.ToLowerInvariant());

            <span class="kwrd">if</span> (IsSingular(word))
                <span class="kwrd">return</span> word;

            var rule = SingularizationRules.Where(ir =&gt; ir.IsValidFor(word.ToLowerInvariant()))
                                          .FirstOrDefault();
            <span class="kwrd">if</span> (rule != <span class="kwrd">null</span>)
                <span class="kwrd">return</span> rule.Apply(word.ToLowerInvariant());

            <span class="kwrd">return</span> word;
        }

        <span class="kwrd">string</span> InternalPluralize(<span class="kwrd">string</span> word)
        {
            DebugCheck.NotEmpty(word);

            <span class="kwrd">if</span> (_userDictionaryEntries.ExistsInFirst(word))
                <span class="kwrd">return</span> _userDictionaryEntries.GetSecondValue(word);

            <span class="kwrd">if</span> (_irregularWords.ExistsInFirst(word))
                <span class="kwrd">return</span> _irregularWords.GetSecondValue(word.ToLowerInvariant());

            <span class="kwrd">if</span> (IsPlural(word))
                <span class="kwrd">return</span> word;

            var rule = PluralizationRules.Where(ir =&gt; ir.IsValidFor(word.ToLowerInvariant()))
                                         .FirstOrDefault();

            <span class="kwrd">if</span> (rule != <span class="kwrd">null</span>)
                <span class="kwrd">return</span> rule.Apply(word.ToLowerInvariant());

            <span class="kwrd">return</span> word;
        }

        <span class="kwrd">private</span> <span class="kwrd">bool</span> IsPlural(<span class="kwrd">string</span> word)
        {
            DebugCheck.NotEmpty(word);

            <span class="kwrd">if</span> (_userDictionaryEntries.ExistsInSecond(word))
                <span class="kwrd">return</span> <span class="kwrd">true</span>;

            <span class="kwrd">if</span> (_irregularWords.ExistsInSecond(word))
                <span class="kwrd">return</span> <span class="kwrd">true</span>;

            <span class="rem">//return if any singularization rule exist</span>
            var rule = SingularizationRules.Where(ir =&gt; ir.IsValidFor(word.ToLowerInvariant()))
                                          .FirstOrDefault();

            <span class="kwrd">return</span> rule != <span class="kwrd">null</span>;
        }

        <span class="kwrd">private</span> <span class="kwrd">bool</span> IsSingular(<span class="kwrd">string</span> word)
        {
            DebugCheck.NotEmpty(word);

            <span class="kwrd">if</span> (_userDictionaryEntries.ExistsInFirst(word))
                <span class="kwrd">return</span> <span class="kwrd">true</span>;

            <span class="kwrd">if</span> (_irregularWords.ExistsInFirst(word))
                <span class="kwrd">return</span> <span class="kwrd">true</span>;

            <span class="kwrd">return</span> <span class="kwrd">false</span>;
        }

        <span class="kwrd">private</span> <span class="kwrd">static</span> <span class="kwrd">bool</span> IsCapitalized(<span class="kwrd">string</span> word)
        {
            <span class="kwrd">return</span> <span class="kwrd">string</span>.IsNullOrEmpty(word) ? <span class="kwrd">false</span> : <span class="kwrd">char</span>.IsUpper(word, 0);
        }

        <span class="kwrd">private</span> <span class="kwrd">static</span> <span class="kwrd">string</span> Capitalize(<span class="kwrd">string</span> word, Func&lt;<span class="kwrd">string</span>, <span class="kwrd">string</span>&gt; action)
        {
            var result = action(word);

            <span class="kwrd">if</span> (IsCapitalized(word))
            {
                <span class="kwrd">if</span> (result.Length == 0)
                {
                    <span class="kwrd">return</span> result;
                }

                var sb = <span class="kwrd">new</span> StringBuilder(result.Length);

                sb.Append(<span class="kwrd">char</span>.ToUpperInvariant(result[0]));
                sb.Append(result.Substring(1));

                <span class="kwrd">return</span> sb.ToString();
            }
            <span class="kwrd">else</span>
            {
                <span class="kwrd">return</span> result;
            }
        }
    }

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

/// <summary>

/// Pluralization service for spanish language.

/// </summary>

public class SpanishPluralizationService

:IPluralizationService

{

BidirectionalDictionary<String, String> _userDictionaryEntries = new BidirectionalDictionary<String, String>();

StringBidirectionalDictionary _irregularWords = new StringBidirectionalDictionary(new Dictionary<string, string>()

{

{"faralá","faralaes"},

{"albalá","albalaes"},

{"no","noes"},

{"gay","gais"},

{"jersey","jerséis"},

{"espray","espráis"},

{"yóquey","yoqueis"},

{"gachí","gachís"},

{"pirulí","pirulís"},

{"popurrí","popurrís"},

{"champú","champús"},

{"menú","menús"},

{"tutú","tutús"},

{"vermú","vermús"},

{"lunes","lunes"},

{"martes","martes"},

{"miércoles","miércoles"},

{"jueves","jueves"},

{"viernes","viernes"},

{"cienpiés","cienpiés"},

{"buscapiés","buscapiés"},

{"pasarurés","pasapurés"},

{"polisíndeton","polisíndeton"},

{"trávelin","trávelin"},

{"cátering","cátering"},

{"hipérbaton","hipérbatos"},

{"imán","imanes"},

{"imam","imames"},

{"álbum","álbumes"},

{"sándwich","sandwiches"},

{"paraguas","paraguas"},

{"tijeras","tijeras"},

{"gafas","gafas"},

{"víveres","víveres"},

{"virus","virus"},

{"atlas","atlas"},

{"déficit","déficit"},

{"crisis","crisis"},

{"tórax","tórax"},

{"fórceps","fórceps"},

{"ratio","ratios"},

{"plus","pluses"},

{"tos","toses"},

{"lapsus","lapsus"},

{"ultimátum", "ultimatos"},

{"memorándum", "memorandos"},

{"referéndum", "referendos"},

{"vals","valses"}

});

private readonly List<ReplacementRule> PluralizationRules =

new List<ReplacementRule>();

private readonly List<ReplacementRule> SingularizationRules =

new List<ReplacementRule>();

/// <summary>

/// Create a new instance

/// </summary>

/// <param name="userDictionaryEntries"></param>

public SpanishPluralizationService(IEnumerable<CustomPluralizationEntry> userDictionaryEntries)

: this()

{

userDictionaryEntries.Each(entry =>

{

_userDictionaryEntries.AddValue(entry.Singular, entry.Plural);

});

}

/// <summary>

/// Create a new instance

/// </summary>

public SpanishPluralizationService()

{

//Add pluralization rules

PluralizationRules.Add(new ReplacementRule("([aeiouáéó])$", "$1s"));

PluralizationRules.Add(new ReplacementRule("([íú])$", "$1es"));

PluralizationRules.Add(new ReplacementRule("([aeiou]+y$)", "$1es"));

PluralizationRules.Add(new ReplacementRule("([b-df-hj-np-tv-z]+)y$", "$1is"));

PluralizationRules.Add(new ReplacementRule("([a-z]+)ás$", "$1ases"));

PluralizationRules.Add(new ReplacementRule("([a-z]+)és$", "$1eses"));

PluralizationRules.Add(new ReplacementRule("([a-z]+)ís$", "$1ises"));

PluralizationRules.Add(new ReplacementRule("([a-z]+)ós$", "$1oses"));

PluralizationRules.Add(new ReplacementRule("([a-z]+)ús$", "$1uses"));

PluralizationRules.Add(new ReplacementRule("([a-z]+)s$", "$1ses"));

PluralizationRules.Add(new ReplacementRule("([aeiou]+)[l]$", "$1les"));

PluralizationRules.Add(new ReplacementRule("([aeiou]+)[r]$", "$1res"));

PluralizationRules.Add(new ReplacementRule("([aeiou]+)[n]$", "$1nes"));

PluralizationRules.Add(new ReplacementRule("([aeiou]+)[d]$", "$1des"));

PluralizationRules.Add(new ReplacementRule("([aeiou]+)[z]$", "$1zes"));

PluralizationRules.Add(new ReplacementRule("([aeiou]+)[j]$", "$1jes"));

PluralizationRules.Add(new ReplacementRule("([a-z]+)ch$", null));

PluralizationRules.Add(new ReplacementRule("(ng|[mwckgtp])$", "$1s"));

//Add singularization rules

SingularizationRules.Add(new ReplacementRule("([ghñpv]e)s$", ""));

SingularizationRules.Add(new ReplacementRule("([bcdfghjklmnñprstvwxyz]{2,}e)s$", "$1"));

SingularizationRules.Add(new ReplacementRule("([^e])s$", "$1"));

SingularizationRules.Add(new ReplacementRule("(oides)$", "oide"));

SingularizationRules.Add(new ReplacementRule("(é)s$", "$1"));

SingularizationRules.Add(new ReplacementRule("(sis|tis|xis)+$", "$1"));

SingularizationRules.Add(new ReplacementRule("(ces)$", "z"));

SingularizationRules.Add(new ReplacementRule("^([bcdfghjklmnñpqrstvwxyz]*)([aeiou])([ns])es$", "$1$2$3"));

SingularizationRules.Add(new ReplacementRule("es$", ""));

}

/// <summary>

/// <see cref="System.Data.Entity.Infrastructure.Pluralization.IPluralizationService"/>

/// </summary>

/// <param name="word"><see cref="System.Data.Entity.Infrastructure.Pluralization.IPluralizationService"/></param>

/// <returns><see cref="System.Data.Entity.Infrastructure.Pluralization.IPluralizationService"/></returns>

public string Pluralize(string word)

{

return Capitalize(word, InternalPluralize);

}

/// <summary>

/// <see cref="System.Data.Entity.Infrastructure.Pluralization.IPluralizationService"/>

/// </summary>

/// <param name="word"><see cref="System.Data.Entity.Infrastructure.Pluralization.IPluralizationService"/></param>

/// <returns><see cref="System.Data.Entity.Infrastructure.Pluralization.IPluralizationService"/></returns>

public string Singularize(string word)

{

return Capitalize(word, InternalSingularize);

}

string InternalSingularize(string word)

{

if (_userDictionaryEntries.ExistsInSecond(word))

return _userDictionaryEntries.GetFirstValue(word);

if (_irregularWords.ExistsInSecond(word))

return _irregularWords.GetFirstValue(word.ToLowerInvariant());

if (IsSingular(word))

return word;

var rule = SingularizationRules.Where(ir => ir.IsValidFor(word.ToLowerInvariant()))

.FirstOrDefault();

if (rule != null)

return rule.Apply(word.ToLowerInvariant());

return word;

}

string InternalPluralize(string word)

{

DebugCheck.NotEmpty(word);

if (_userDictionaryEntries.ExistsInFirst(word))

return _userDictionaryEntries.GetSecondValue(word);

if (_irregularWords.ExistsInFirst(word))

return _irregularWords.GetSecondValue(word.ToLowerInvariant());

if (IsPlural(word))

return word;

var rule = PluralizationRules.Where(ir => ir.IsValidFor(word.ToLowerInvariant()))

.FirstOrDefault();

if (rule != null)

return rule.Apply(word.ToLowerInvariant());

return word;

}

private bool IsPlural(string word)

{

DebugCheck.NotEmpty(word);

if (_userDictionaryEntries.ExistsInSecond(word))

return true;

if (_irregularWords.ExistsInSecond(word))

return true;

//return if any singularization rule exist

var rule = SingularizationRules.Where(ir => ir.IsValidFor(word.ToLowerInvariant()))

.FirstOrDefault();

return rule != null;

}

private bool IsSingular(string word)

{

DebugCheck.NotEmpty(word);

if (_userDictionaryEntries.ExistsInFirst(word))

return true;

if (_irregularWords.ExistsInFirst(word))

return true;

return false;

}

private static bool IsCapitalized(string word)

{

return string.IsNullOrEmpty(word) ? false : char.IsUpper(word, 0);

}

private static string Capitalize(string word, Func<string, string> action)

{

var result = action(word);

if (IsCapitalized(word))

{

if (result.Length == 0)

{

return result;

}

var sb = new StringBuilder(result.Length);

sb.Append(char.ToUpperInvariant(result[0]));

sb.Append(result.Substring(1));

return sb.ToString();

}

else

{

return result;

}

Bien, ahora que ya tenemos el pluralizador creado, para establecerlo lo tenemos tan fácil como usar nuestro DbConfiguration.

    <span class="kwrd">public</span> <span class="kwrd">class</span> Configuration
        :DbConfiguration
    {
        <span class="kwrd">public</span> Configuration()
        {
            <span class="rem">//...</span>

            SetPluralizationService(<span class="kwrd">new</span> SpanishPluralizationService());

           <span class="rem">//...</span>
        }
    }

public class Configuration

:DbConfiguration

{

public Configuration()

{

//...

SetPluralizationService(new SpanishPluralizationService());

//...

}

&nbsp;

Saludos

Saludos

Unai

Unai

EF 6: Un ejemplo de pluralizador en castellano

Un comentario sobre “EF 6: Un ejemplo de pluralizador en castellano”

Deja un comentario Cancelar respuesta