Come caricare i caratteri? | Soluzione API per .NET

Panoramica

Per rispondere alla domanda, come caricare i caratteri, prima dobbiamo apprendere che qualsiasi carattere è fisicamente una serie di byte in cui i dati sono rappresentati in un formato. Pertanto, per il caricamento del carattere corretto è necessario conoscere due parametri chiave:

• Formato di carattere. I caratteri possono avere formati diversi come truetype, type1, ecc.
• Archiviazione, in cui vengono tenuti i dati binari che rappresentano il carattere. Ogni carattere è rappresentato come dati binari ma il modo in cui questi dati sono archiviati può differire. Nella maggior parte dei casi, il carattere viene archiviato come file su un disco rigido. Ma a volte i dati binari di carattere possono essere inseriti in un file diverso che non è un carattere stesso. Ad esempio, i file creati da Microsoft Word o Adobe Acrobat. Questi sono file con estensioni .docx, .pdf. Possono includere caratteri diversi.

Oggetti e parametri richiesti per il caricamento del carattere

Aspose.Font per .NET fornisce oggetto FontDefiniton per avvisare due parametri chiave richiesti per il caricamento del carattere. Dopo aver creato e avviato FontDefiniton Oggetto, devi solo chiamare il metodo statico Aspose.Font.Font.Open() e passare oggetto appena inizializzato FontDefiniton come parametro per caricare il carattere desiderato e ottenere un riferimento su di esso.

Descriviamolo con lo pseudocodice:

 
using Aspose.Font;
    ...

    // Initialize object FontDefinition with appropriate properties
    FontDefinition fontDef = new FontDefinition(); 
    Font desiredFont = Font.Open(fontDef);

Il risultato finale del caricamento del carattere sta ottenendo un tipo di tipo Aspose.Font.Font. Class Aspose.Font.Font è una classe di carattere di base di Aspose.Font per la libreria .net. Rappresenta la principale funzionalità del lavoro con i caratteri.

Essere caricato un carattere in Aspose.Font.Font Digitare oggetto che sarai in grado di rendere il testo con questo carattere, ottenere dati di codifica e metriche di carattere. Sarai anche in grado di modificare o salvare questo carattere e molti altri.

Per iniziare l’oggetto FontDefiniton di cui abbiamo bisogno, come menzionato in precedenza, per dargli 2 parametri di carattere, - il tipo di formato e l’oggetto che descrive l’archiviazione per i dati binari del carattere. Il primo parametro viene avvisato con enumerazione FontType*.

Per semplificare il lavoro con il secondo parametro, Aspose.Font offre una serie di oggetti che danno accesso universale ai dati binari del carattere indipendentemente da dove viene posizionato il carattere.

Questo accesso universale è collegato a una cosa come un flusso di byte. Quindi, indipendentemente da dove viene inserito il carattere - in un file su un disco, all’interno di un altro file, array di byte in memoria - in ogni caso, gli oggetti speciali Aspose.Font forniranno un accesso al flusso di byte, relativo al carattere desiderato.

Descriviamo questi oggetti:

1. StreamSource classe. Questa classe di base astratta definisce le proprietà e i metodi che danno accesso al flusso di byte di carattere. GetFontstream() di questa classe restituisce un flusso, relativo ai dati del carattere binario. Proprietà offset punti sulla posizione in questo flusso, da dove dobbiamo iniziare a leggere i dati.
2. Due classi più usate ereditate dalla base StreamSource:
   • FilesystemStreamSource - Progettato per fornire l’accesso al flusso, in base al file system. Proprietà nome file restituisce il nome del file di carattere. Getfontstream() il metodo restituisce un flusso di byte, relativo a questo file.
   • ByteContentstreamSource - fornisce accesso al flusso, in base all’array di byte.

Come iniziare le lezioni?

Ecco esempi dell’iniziazione di queste classi.

1. Supponiamo che il carattere sia nel file chiamato lora.ttf. In questo caso, per ottenere l’accesso al flusso di byte di questo carattere dobbiamo creare l’oggetto di tipo FilesystemStreamSource usando questo singolo costruttore:

 
    FilesystemStreamSource fonsource = new FilesystemStreamSource ("LORA.TTF");

2. Se i dati binari del carattere si trovano in un array binario definito dalla variabile Fontarray byte [], allora un oggetto di tipo bytecontentstreamsource fornirà un accesso al flusso di dati del carattere, in base alla variabile Fontarray. Per ottenere l’accesso al flusso di byte di carattere, dobbiamo creare un oggetto di tipo ByteContentStreamSource per ottenere l’accesso al flusso, relativo all’array di byte di carattere usando codice come questo:

 
    ByteContentstreamSource fonsource = new ByteContentstreamSource (Fontarray);

Pertanto, per fornire l’accesso ai dati binari del carattere, utilizzare gli oggetti ereditati dalla classe Base StreamSource. Inoltre, chiameremo tali oggetti Font Stream Sources.

Oggetto FontFileDefinition

La maggior parte dei fronti si trova in file normali ma allo stesso tempo, parte dei caratteri può avere origini di dati diverse. Per partecipare a un unico oggetto File e Font Binary Stream, Aspose.Font La libreria fornisce un oggetto speciale fontfiledefinition.

Questo oggetto ha tali proprietà:

• Nome file - nome del file di carattere.
• FileExtension - Estensione di un file di carattere.
• StreamSource - Fonte Font Stream.
• Offset - Offset all’interno del flusso di byte di carattere.

Il più semplice e uno dei costruttori più utilizzati di questo oggetto è il costruttore con la seguente firma: fontFileDefinition (FileInfo FontFile), usa questo costruttore per i casi in cui il carattere desiderato è in un file sul disco rigido.

Ecco un esempio di avvio di tale oggetto per il carattere Montserrat che si trova nel file C:\Windows\Fonts\Montserrat.ttf:

 
    FontFileDefinition FileDedef = new FontFileDefinition (new FileInfo (@"C:\Windows\Fonts\Montserrat.ttf"));

Inoltre, fontFileDefinition può fare riferimento al carattere Montserrat usando i seguenti costruttori:

 
    FontFileDefinition FileDedef = new FontFileDefinition (new FilesystemStreamSource (@"C:\Windows\Fonts\Montserrat.ttf"));

    FontFileDefinition fileDef = new FontFileDefinition("ttf", new FileSystemStreamSource(@"C:\Windows\Fonts\Montserrat.ttf"));

Il parametro fileExtension deve corrispondere all’estensione standard per il formato del font. Ad esempio, se il formato del font è TrueType, il valore del parametro fileExtension può essere ttf o ttc (se il file del font è una raccolta di font TrueType). Se il formato del font è Embedded Open Type, il valore del parametro fileExtension deve essere eot.

La tabella seguente mostra il più spesso utilizzato in Aspose.Font per i formati di file .NET FONT. Ci sono con i valori di corrispondenza che dovrebbe assumere il parametro fileextension.

Formato file font	Estensionefile
TrueType, font singolo	ttf
Raccolta di font TrueType`	ttc
Web Open Font Format	woff
Web Open Font Format versione 2.0	woff2
Embedded OpenType	eot
Font Adobe Type 1	pfa, pfb, afm, pfm
Compact Font Format	cff, può essere nullo

Se i dati del carattere non iniziano dalla posizione 0 del flusso di byte, utilizzare il seguente costruttore con il parametro offset:

 
    FontFileDefinition (String FileExtension, StreamSource StreamSource, Long Offset).

Come avviare l’oggetto FontDefinition?

Ora, quando hai un’idea degli oggetti ereditati dalla classe StreamSource e fornendo accesso al flusso di byte di carattere, e dell’oggetto fontfiledefinition, ti spiegheremo come avviare FontDefiniton oggetto con questi oggetti correttamente per le diverse situazioni.

FontDefiniton L’oggetto fornisce molti costruttori sovraccarichi. La caratteristica comune di tutti i costruttori esistenti è il parametro FontType. Descrive il tipo di formato carattere. Come accennato in precedenza, a parte il valore FontType, oggetto FontDefiniton dovrebbe essere inizializzato con riferimento ai dati binari del carattere.

I parametri successivi di FontDefiniton possono essere utilizzati in questo caso:- FontName;

• fileextension;
• Oggetto del tipo StreamSource;
• Oggetto del tipo fontFileDefinition.

Potresti avere una domanda. Perché dovremmo passare il parametro fileExtension all’oggetto FontDefiniton o all’oggetto FontFileDefinition, quando passiamo sempre il parametro FontType che sembra coincidere per valore con fileExtension? Il problema è che FontType non sempre coincide con il valore di fileExtension. FontType definisce il formato font comune, ma non quello di un file specifico. Alcuni font di un formato possono avere formati di file diversi. Ad esempio, il valore FontType.TTF definisce il formato TrueType. Allo stesso tempo, TrueType include alcuni formati font e contiene file font con estensioni ttf, eot, ttc, ecc. E se, ad esempio, per il font in formato EOT passiamo a FontDefiniton solo il valore FontType.TTF, come farà questo oggetto a capire che il font appartiene al formato EOT e non a TTF? Allo stesso modo, il valore di FontType.Type1 è la definizione comune per i font di questo formato. Allo stesso tempo, i file di font in formato Type1 hanno estensioni .pfa, .pfb, .afm, .pfm. Quindi non è possibile definire correttamente il formato del file di font basandosi solo sul valore FonType.Type1. Pertanto, per definire correttamente il formato del font, dobbiamo specificare il parametro FontType con il valore del parametro fileExtension.

Di seguito puoi imparare esempi di FontDefiniton Inizializzazione dell’oggetto e seguendo il caricamento dei caratteri per diversi casi.

In tutti i casi il risultato del caricamento del carattere finale viene inserito nella variabile di tipo Aspose.Font.Font. Questo tipo è la classe di caratteri di base di Aspose.Font Documentation e oggetti di questo tipo forniscono funzionalità di base comuni per funzionare con i caratteri. Caricamento del carattere in questo oggetto sarai in grado di rendere il testo con questo carattere, ottenere informazioni di codifica, metriche di carattere, ecc.

Esempi di come caricare i caratteri

Facciamo come esempio, caricando il carattere montserrat dal file C:\Windows\Fonts\Montserrat.ttf

Aggiungi gli spazi dei nomi successivi alla testa del file:

    using System;
    using Aspose.Font;
    using Aspose.Font.Sources;
    using System.IO;

È possibile caricare questo carattere usando FontDefiniton e fontFileDefinition oggetti in diversi modi:

Caricamento con l’aiuto di System.io.FileInfo Oggetto

Per soddisfare il caricamento fai il prossimo:

1. Costruisci percorso al file.
2. Inizia FontDefiniton Passando ttf as FontType valore.
3. Ottenere valore calcolato automaticamente fileextension.
4. Carica il carattere.

    // Costruisci percorso al file
    String fontPath = @"C:\Windows\Fonts\Montserrat.ttf";

    // Initialize FontDefinition object passing TTF as FontType value and using FontFileDefinition
    FontFileDefinition fileDef = new FontFileDefinition(new FileInfo(fontPath));

    // Based on FileInfo object, fileExtension value is calculated automatically from FileInfo fields.
    FontDefinition fontDef = new FontDefinition(FontType.TTF, fileDef);
	
    // Load font
    Font font = Font.Open(fontDef);

Caricamento con l’aiuto di FilesystemStreamSource Type Object

Prendi i passaggi successivi per eseguire l’operazione:

1. Costruisci percorso al file.
2. Inizia FontDefiniton.
3. Imposta fileextension su ttf.
4. Carica il carattere.

    // Costruisci percorso al file
    String fontPath = @"C:\Windows\Fonts\Montserrat.ttf";

    // Initialize FontDefinition object passing TTF as FontType value and using FontFileDefinition
    FontFileDefinition fileDef = new FontFileDefinition("ttf", new FileSystemStreamSource(fontPath));

    // Based on FileSystemStreamSource object, set fileExtension to "ttf"
    FontDefinition fontDef = new FontDefinition(FontType.TTF, fileDef);
		
    // Load font   
    Font font = Font.Open(fontDef);

Caricamento del carattere senza obiettivo FontFileDefinition, con il passaggio di FileSystemStreamSource direttamente a FontDefinition

Le prossime azioni devono essere intraprese per caricare il carattere in questo modo:

1. Costruisci percorso al file.
2. Avvia FontDefiniton Passando `` Parametro fileextension Non è un valore duplicato per il parametro FontType.
3. Carica il carattere.

    // Costruisci percorso al file
    String fontPath = @"C:\Windows\Fonts\Montserrat.ttf";
    // Initialize FontDefinition object passing TTF as FontType value, "ttf" as fileExtension value, 
    // and FileSystemStreamSource object. Parameter 'fileExtension' here is not duplicate value 
    // for parameter 'FontType' and it's needed for correct font format detection
    FontDefinition fontDef = new FontDefinition(FontType.TTF, "ttf", new FileSystemStreamSource(fontPath));

    // Load font	
    Font font = Font.Open(fontDef);

Caricamento del carattere con la variabile Byte [] Digita e con l’utilizzo di ByTeContentstreamSource

Per caricare un carattere dall’array di byte è necessario:

1. Costruisci percorso al file.
2. Carica i dati binari del carattere nell’array di byte
3. Inizializza FontDefiniton Passando ``
4. Carica il carattere.

    // Costruisci percorso al file
    String fontPath = @"C:\Windows\Fonts\Montserrat.ttf";

    // Load font binary data into byte array
    byte[] fontBytes;

    // Initialize FontDefinition object  passing TTF as FontType value, "ttf" as fileExtension value, 
    // and ByteContentStreamSource object based on fontBytes array
    FontDefinition fontDef = new FontDefinition(FontType.TTF, "ttf", new ByteContentStreamSource(fontBytes));
	
    // Load font	
    Font font = Font.Open(fontDef);

Per ottenere altri esempi di utilizzo di Aspose.Font, vai su aspose.font.examples.sln Solution, in net-examples della documentazione Aspose.Font

In caso di problemi o domande, puoi pubblicarli nella sezione Aspose.Font.Product del Forum di supporto libero e in poche ore il nostro team di supporto chiarirà tutto per te.