Come creare un indice in Entity Framework 6.2 con il codice prima




 C'è un modo per creare un indice su una proprietà / colonna usando codice-prima, invece di usare il nuovo [`IndexAttribute`](https://msdn.microsoft.com/en-us/library/jj591583(v=vs.113).aspx#Anchor_10) ?
Bene 26.10.2017 Entity Framework 6.2 è stato [ufficialmente rilasciato](https://blogs.msdn.microsoft.com/dotnet/2017/10/26/entity-framework-6-2-runtime-released/) . Include la [possibilità](https://github.com/aspnet/EntityFramework6/issues/274) di definire facilmente gli indici tramite l'API Fluent. Ho è stato già [annunciato](https://blogs.msdn.microsoft.com/dotnet/2017/05/23/announcing-ef-6-2-beta-1/#fluent-api-to-define-indexes-274) nella versione beta di 6.2. 

 Ora puoi usare il metodo `HasIndex()` , seguito da `IsUnique()` se dovrebbe essere un indice univoco. 

 Solo un piccolo esempio di confronto (prima / dopo): 


```
// before 
modelBuilder.Entity<Person>()
        .Property(e => e.Name)
        .HasColumnAnnotation(
            IndexAnnotation.AnnotationName, 
            new IndexAnnotation(new IndexAttribute { IsUnique = true }));

// after
modelBuilder.Entity<Person>()
    .HasIndex(p => p.Name)
    .IsUnique();

// multi column index
modelBuilder.Entity<Person>()
    .HasIndex(p => new { p.Name, p.Firstname })
    .IsUnique();

```
  È anche possibile contrassegnare l'indice come cluster con. `.IsClustered()` . 





 **MODIFICA # 1** 

 Aggiunto un esempio per l'indice multi colonna e informazioni aggiuntive su come contrassegnare un indice come cluster. 





 **MODIFICA # 2** 

 Come informazioni aggiuntive, in EF Core 2.1 è esattamente la stessa di EF 6.2 ora.   
 [Ecco](https://docs.microsoft.com/de-de/ef/core/modeling/indexes) la artcile di MS Doc come riferimento.
<p>la seconda sintassi è semplicemente un collegamento che consente di specificare la colonna e aggiungere un indice su di essa in una singola clausola.</p><p>questo funziona bene nei casi in cui si desidera semplicemente creare una colonna e aggiungere un indice su di essa.</p><p>dovrai utilizzare la prima sintassi se vuoi fare qualcosa di più complicato, come aggiungere un indice basato su più colonne anziché una singola colonna, o se stai aggiungendo o modificando un indice su una colonna esistente; cioè, non stai creando la colonna e l'indice su di essa contemporaneamente.</p> L'albero delle espressioni è così potente perché ti consente di trattare il **codice** come **dati** . Gli utenti sono abituati a creare dati, salvarli e tornare in seguito. 

 Gli alberi delle espressioni ti consentono di fare la stessa cosa con il codice. Ad esempio, puoi inserire l'input dell'utente (caselle di controllo, intervalli numerici, ecc.) E tradurlo in un albero di espressioni. Quell'albero di espressioni può quindi essere eseguito o memorizzato per un uso successivo. Molto bello 

 Pensa agli usi pratici relativi alla creazione di rapporti come la creazione e il salvataggio di filtri dati e mappature dei dati. Un altro uso pratico sarebbe quello di supportare flussi di lavoro personalizzati nell'applicazione in base a regole definite dall'utente. 

 Ecco un po 'di codice MSDN sulla serializzazione di alberi di espressioni ( <http://code.msdn.microsoft.com/exprserialization> ) che dovrebbe far scorrere le idee. <p>spesso, una condizione if lunga è il segno di codice che necessita di refactoring, ma a volte non è possibile evitarlo. in questi casi, preferisco il primo:</p><pre><code>if (bar || baz || quux) { ... } </code></pre><p>perché sei in grado di dire cosa sta succedendo con una riga. tuttavia, preferirei fare qualcosa del genere, quando possibile:</p><pre><code>function foo() { return bar || baz || quux; } if (foo()) { ... } </code></pre> <p>dipende dal documento .php in cui ti trovi - se ti trovi in ​​item.php, o nei file category-item.php, dovrebbe funzionare quanto segue.</p><p>nella parte superiore del documento, aggiungi questo codice:</p><pre><code>&lt;!-- call to prepare extra fields --&gt; &lt;?php $extrafields = array(); foreach($this-&gt;item-&gt;extra\_fields as $item) { $extrafields[$item-&gt;id] = $item-&gt;value; } ?&gt; </code></pre><p>quindi, ovunque tu voglia chiamare il valore del campo compilato, usa questo:</p><pre><code>&lt;?php if($extrafields[id\_number\_of\_field]!=''):?&gt; &lt;!-- if filled in, then call data --&gt; &lt;?php echo $extrafields[id\_number\_of\_field];?&gt; &lt;!-- actual data call --&gt; &lt;?php endif; ?&gt; </code></pre><p>tag.php funziona in modo leggermente diverso, così come i moduli k2.</p><p>tag.php - non è necessario il codice aggiuntivo in testa, quanto segue chiamerà i dati del campo.</p><pre><code>&lt;?php $extrafields = json\_decode($item-&gt;extra\_fields);?&gt; &lt;?php foreach($extrafields as $key=&gt;$value): ?&gt; &lt;?php if($extrafields[$key]-&gt;id == 'id\_number\_of\_field'&amp;&amp;$extrafields[$key]-&gt;value!=''): ?&gt; &lt;?php echo $extrafields[$key]-&gt;value; ?&gt;, &lt;?php endif; ?&gt; &lt;?php endforeach; ?&gt; </code></pre><p>ancora una volta, con module\_k2\_content, non è necessaria la prima chiamata di dati. ottieni i dati sul campo in questo modo:</p><pre><code>&lt;?php echo $item-&gt;extrafields-&gt;alias\_of\_field-&gt;value ;?&gt; </code></pre><p>spero che sia d'aiuto.</p> non si può fare in html, dovrai impararti il php come minimo (codice che io consiglio vivamente). Se vuoi una rappresentazione testuale dell'espressione e non ti interessa come appare esattamente, puoi usare `ToString()` . Tutti i tipi di [`Expression`](http://msdn.microsoft.com/en-us/library/system.linq.expressions) sostituiscono questo metodo. 

 Ad esempio, per l'espressione semplice `num => num < 5` , `ToString()` restituisce `num => (num < 5)` . Ma per espressioni più complicate, non sembra più il codice C #. Ad esempio, per `num => num < Math.Pow(5,5)` , restituisce `num => (Convert(num) < Pow(5, 5))` . È necessario eseguire un po 'di interoperabilità Win32 per ottenere questo effetto. A seconda che tu stia utilizzando Winforms o WPF, il modo in cui ti colleghi all'elaborazione dei messaggi è diverso (non ricordo Winforms, quindi fornirò tutti gli esempi per WPF). Ma in entrambi i casi, è necessario:


1. Intercettare la creazione della finestra e modificare gli stili di finestra e gli stili estesi. In WPF è necessario ereditare da [`HwndSource`](https://msdn.microsoft.com/en-us/library/system.windows.interop.hwndsource.aspx) e modificare lo [`HwndSourceParameters`](https://msdn.microsoft.com/en-us/library/system.windows.interop.hwndsourceparameters.aspx) per raggiungere questo obiettivo. Sono necessari WS\_OVERLAPPEDWINDOW, WS\_CLIPSIBLINGS e WS\_VISIBLE per gli stili estesi stile standard e WS\_EX\_WINDOWEDGE e WS\_EX\_APPWINDOW.
2. Aggiungere un gestore di messaggi tramite i parametri HwndSource HwndSourceHook.
3. Nel proc messaggio aggiunto attraverso il gancio nella fase due, è necessario elaborare diversi messaggi:


	* [`WM_NCACTIVATE`](https://msdn.microsoft.com/en-us/library/ms632633(VS.85).aspx) - per cambiare il quadro del titolo quando l'applicazione è attiva o meno
	* [`WM_NCCALCSIZE`](https://msdn.microsoft.com/en-us/library/ms632634(VS.85).aspx) - per tornare al sistema operativo che non si dispone di aree non-client
	* [`WM_NCPAINT`](https://msdn.microsoft.com/en-us/library/dd145212(VS.85).aspx) - in generale, è necessario invaldate rECT finestra solo qui, il WPF si prenderà cura della pittura reale)
	* [`WM_NCHITTEST`](https://msdn.microsoft.com/en-us/library/ms645618(VS.85).aspx) - per elaborare lo spostamento della finestra, riducendo al minimo e massimizzando.
4. Una volta eseguito quanto sopra, l'area client in cui WPF sta per dipingere l'albero visivo coprirà l'intera area della finestra. Sarà necessario aggiungere le immagini "non-cliet" in modo che l'applicazione assomigli a un'applicazione normale per l'utente.
5. Potrebbe essere necessario molti più messaggi:


	* [`WM_THEMECHANGED`](https://msdn.microsoft.com/en-us/ms632650.aspx) se si desidera modificare il "non-client" pittura zona di essere coerente con il tema del sistema operativo
	* [`WM_DWMCOMPOSITIONCHANGED`](https://msdn.microsoft.com/en-us/library/aa969230(VS.85).aspx) se si desidera estendere vetro e ottenere la verniciatura a vetro standard OS OS quando il vetro è abilitato e passare alla logica personalizzata quando il vetro non lo è.
6. Si potrebbe desiderare di guardare le API Win32 a tema se si vuole andare a prendere i beni Win32 standard per le frontiere, caption, stretta, mininmize e massimizzare i pulsanti da utilizzare nel settore 'non-client".
7. Se si desidera estendere Glass nella finestra, si può guardare:


	* [`DwmExtendFrameIntoClientArea`](https://msdn.microsoft.com/en-us/library/aa969512(VS.85).aspx) - per ottenere il vetro standard NC-zona
	* [`DwmDefWindowProc`](https://msdn.microsoft.com/en-us/library/aa969507(VS.85).aspx) - per ottenere il desktop manager per dipingere Vetro e i comandi NC standard
	* [`DwmIsCompositionEnabled`](https://msdn.microsoft.com/en-us/library/aa969518.aspx) - per determinare se Glass è abilitato; puoi utilizzare le due API precedenti solo quando Glass è abilitato. Se Glass non è abilitato, è necessario eseguire il proprio disegno dell'area NC.


Si possono trovare delle definizioni appropriate C# di tutti i messaggi, stili e corrispondenti API Win32 che vi serve sul [P/Invoke](http://pinvoke.net).


È inoltre possibile ottenere risultati simili utilizzando la finestra standard WPF con `WindowStyle=none`. Tuttavia, ci saranno alcune differenze tra il comportamento del desktop verso la tua app e altre app; il più ovvio è che non sarà possibile impilare o affiancare la finestra facendo clic con il tasto destro sulla barra delle applicazioni.


È anche possibile esaminare alcuni componenti di terze parti che abilitano alcune di queste funzionalità. Non ne ho usato nessuno (come potete vedere, non ho paura dell'interop di Win32 :-)), quindi non posso raccomandarvi alcun particolare. mizzega, non è semplice, sai programmare?
comunque ti consiglio inizia a prepararti le pagine con le informazioni, le prime, poi creati il motore di ricerca e prova il tutto, se funziona prova a crearti un installer, comunque sara mooolto pesante e dura, altrimenti prova con excel Peter Vogel: Sarebbe bello se potessi chiamare i metodi Blazor C # dal tuo codice JavaScript. In questo momento, non è del tutto possibile: semplicemente chiamare Blazor C # da JavaScript non funzionerà (riceverai un messaggio su un dispatcher di chiamate che non è disponibile). 

 Quello che puoi fare, tuttavia, è una volta che il tuo codice Blazor è in esecuzione, chiama il codice JavaScript dal tuo codice C #. Dopo averlo fatto, il codice JavaScript può, a sua volta, chiamare il codice Blazor. 

 Spero che questo risolva il problema ... <p>al livello più basso, winrt è un modello a oggetti definito a livello abi. usa com come base (quindi ogni oggetto winrt implementa <code>iunknown</code> e ricontatta), e costruisce da lì. aggiunge molti nuovi concetti rispetto a com di vecchi, molti dei quali provengono direttamente da .net - ad esempio, il modello a oggetti winrt ha delegati e gli eventi sono fatti in stile .net (con delegati e aggiungi/rimuovi abbonato metodi, uno per evento) anziché il vecchio modello com di origini e sink di eventi. tra le altre cose degne di nota, winrt ha anche interfacce parametrizzate ("generiche").</p><p>un altro grande cambiamento è che tutti i componenti winrt hanno metadati disponibili per loro, proprio come gli assembly .net. in com è una specie di quello con typelibs, ma non tutti i componenti com li avevano. per winrt, i metadati sono contenuti nei file .winmd - guarda dentro "c:\programmi (x86)\windows kits\8.0\windows metadata \" in anteprima sviluppatore. se cerchi, vedrai che in realtà sono assiemi cli senza codice, solo tabelle di metadati. puoi aprirli con ildasm, in effetti. nota, questo non significa che winrt stesso sia gestito, ma semplicemente riutilizza il formato del file.</p><p>quindi ci sono un certo numero di librerie implementate in termini di quel modello di oggetti - che definiscono le interfacce e le classi winrt. ancora una volta, guarda la cartella "windows metadata" di cui sopra per vedere cosa c'è lì; o semplicemente avvia object browser in vs e seleziona "windows 8.0" nel selettore di framework, per vedere cosa è coperto. c'è molto lì e non si occupa solo dell'interfaccia utente: ottieni anche spazi dei nomi come <code>windows.data.json</code>, o <code>windows.graphics.printing</code>, o <code>windows.networking.sockets</code>.</p><p>quindi ottieni diverse librerie, che si occupano in particolare dell'interfaccia utente, per lo più si tratta di vari spazi dei nomi in <code>windows.ui</code> o <code>windows.ui.xaml</code>. molti di loro sono molto simili agli spazi dei nomi wpf/silverlight - ad es. <code>windows.ui.xaml.controls</code> è strettamente corrispondente <code>system.windows.controls</code>; idem per <code>windows.ui.xaml.documents</code> eccetera.</p><p>ora .net ha la possibilità di fare riferimento direttamente ai componenti winrt come se fossero assembly .net. funziona diversamente dall'interoperabilità com: non hai bisogno di artefatti intermedi come gli interoperativi, devi solo <code>/r</code> un file .winmd e tutti i tipi e i relativi membri nei suoi metadati diventano visibili a te come se fossero oggetti .net. si noti che le stesse librerie winrt sono completamente native (e quindi i programmi c++ nativi che utilizzano winrt non richiedono affatto clr) - la magia per esporre tutta quella roba come gestita è all'interno del clr stesso, ed è di livello abbastanza basso. se ildasm un programma .net che fa riferimento a un .winmd, vedrai che in realtà sembra un riferimento esterno all'assemblea - non ci sono giochi di prestigio come il tipo di inserimento lì.</p><p>non è nemmeno una mappatura smussata - clr tenta di adattare i tipi di winrt ai loro equivalenti, ove possibile. quindi ad es. guid, date e uri diventano <code>system.guid</code>, <code>system.datetime</code> e <code>system.uri</code>, rispettivamente; interfacce di raccolta winrt come <code>iiterable&lt;t&gt;</code> e <code>ivector&lt;t&gt;</code> diventa <code>ienumerable&lt;t&gt;</code> e <code>ilist&lt;t&gt;</code>; e così via. questo funziona in entrambi i modi: se si dispone di un oggetto .net che implementa <code>ienumerable&lt;t&gt;</code> e restituiscilo a winrt, lo vedrà come <code>iiterable&lt;t&gt;</code>.</p><p>in definitiva, ciò significa che le tue app .net metro hanno accesso a un sottoinsieme delle librerie .net standard esistenti e anche alle librerie (native) winrt, alcune delle quali - in particolare <code>windows.ui</code> - sembra molto simile a silverlight, per quanto riguarda le api. hai ancora xaml per definire la tua ui e gestisci ancora gli stessi concetti di base di silverlight: associazioni di dati, risorse, stili, modelli ecc. in molti casi, è possibile eseguire il porting di un'app silverlight semplicemente con <code>using</code> i nuovi spazi dei nomi e modificando alcuni punti del codice in cui l'api è stata modificata.</p><p>winrt stesso non ha nulla a che fare con html e css, e ha relazione con javascript solo nel senso che è anche esposto lì, in modo simile a come viene fatto per .net. non è necessario avere a che fare con html/css/js quando si utilizzano le librerie dell'interfaccia utente winrt nella propria app .net metro (beh, immagino, se proprio lo si desidera, è possibile ospitare un controllo <code>webview</code>. .). tutte le tue competenze .net e silverlight rimangono molto rilevanti in questo modello di programmazione.</p>