Used to report errors from the ContentManager.Load method. All the properties and methods are inherited from Exception.

The runtime component that loads managed objects from the binary files produced by the design-time Content Pipeline. It also manages the lifespan of the loaded objects. Disposing of the content manager will also dispose of any assets that are themselves IDisposable.

A worker object that implements most of ContentManager.Load. A new ContentReader is constructed for each asset loaded. Most of the properties and methods are derived from BinaryReader.

A custom Attribute that marks a field or property to control how it is serialized or to indicate that protected or private data should be included in serialization.

A custom Attribute that marks a collection class to specify the XML element name for each item in the collection.

A custom Attribute that marks public fields or properties to prevent them from being serialized. All properties and methods are inherited from Attribute.

A custom Attribute that specifies the corresponding runtime type of this object.

A custom Attribute that specifies the corresponding runtime type version of this object.

Worker for reading a specific managed type from a binary format. Derive from this class to add new data types to the Content Pipeline system.

A manager that constructs and keeps track of type reader objects.

Subclass of ContentManager, which is specialized to read from RESX resource files rather than directly from individual files on disk. Most of the properties and methods are inherited from ContentManager.

Add a new file to the Content Pipeline extension project using the Project, Add New Item menu command. The Add New Item dialog box opens. Click XNA Game Studio 4.0 under Visual C# Items in the left column; then click Content Importer, as shown in Figure 5.2.

Figure 5.2. Adding the Content Importer class to the Content Pipeline extension project.

Following is the source code for the importer class, called TextImporter in this example. The purpose of this class is threefold:

In the case of your text file importer, only one line of code is needed to read the entire text file into a string variable in memory. Note the namespace used in these classes: TextContentPipelineExtension.

using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content.Pipeline;

using TImport = System.String;

namespace TextContentPipelineExtension
{
    [ContentImporter(".txt", DisplayName = "Text File Importer",
        DefaultProcessor = "TextProcessor")]
    class TextImporter : ContentImporter<TImport>
    {
        public override TImport Import(string filename,
            ContentImporterContext context)
        {
            return System.IO.File.ReadAllText(filename);
        }
    }
}

The next class we need in the extension library project is the Processor, which has the job of converting the input data from the Importer into whatever format needed in the resulting XNB file (which will be written using the Writer class). You need a new class for the Processor, so add it via the Project, Add New Item menu command. The Add New Item dialog box opens. Click XNA Game Studio 4.0 under Visual C# Items in the left column; then click Content Processor, as shown in Figure 5.3.

Figure 5.3. Adding the Content Processor class to the project.

Here is the source code for the sample TextProcessor class. This very simple class just passes the string read in from the text file to Writer. Normally, you would need to do some processing on the input data to make it palatable within the XNA game. For instance, an image file loader would need to convert the read bytes into data compatible with a Texture or Texture2D class. In the interest of keeping this example simple, I’m just working with character data.

using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content.Pipeline;
using Microsoft.Xna.Framework.Content.Pipeline.Processors;

using TInput = System.String;
using TOutput = GameLibrary.MyData;

namespace TextContentPipelineExtension
{
    [ContentProcessor(DisplayName = "Text File Processor")]
    public class TextProcessor : ContentProcessor<TInput, TOutput>
    {
        public override TOutput Process(TInput input,
            ContentProcessorContext context)
        {
            GameLibrary.MyData data = new GameLibrary.MyData();
            data.MyString = input;
            return data;
        }
    }
}

Now we have the Writer class. After the Processor class manipulates data read in by Importer into whatever format we need to use, the Writer class writes the data passed to it from Processor out to an XNA file with an extension of .xnb. To add a Writer class, run the Project, Add New Item menu command. The Add New Item dialog box opens; click XNA Game Studio 4.0 under Visual C# Items in the left column; then click Content Writer, as shown in Figure 5.4.

Figure 5.4. Adding the Content Type Writer class to the project.

The source code for the TextWriter class is shown in Listing 5.1. Normally, there would be more than one line of code to write out the data for a custom asset file, but because we’re just working with text data, we only need to write out the string to a text file. This is kept simple to demonstrate how the project works. After you’ve learned how to create a Content Pipeline extension, you will be able to work with more complex file types.

using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content.Pipeline;
using Microsoft.Xna.Framework.Content.Pipeline.Processors;
using Microsoft.Xna.Framework.Content.Pipeline.Serialization.Compiler;

using TWrite = GameLibrary.MyData;

namespace TextContentPipelineExtension
{
    [ContentTypeWriter]
    public class TextWriter : ContentTypeWriter<TWrite>
    {
        protected override void Write(ContentWriter output, TWrite value)
        {
            //write the .xnb file
            output.Write(value.MyString);
        }
        public override string GetRuntimeReader(TargetPlatform target
Platform)
        {
            return "GameLibrary.TextReader, GameLibrary";
        }
    }
}

The Reader class is not part of the Content Pipeline, but is instead a class in the game project. The Reader is responsible for reading the XNB file that has been pre-processed by the custom Content Pipeline extension library (see Listing 5.2). The reason this class is not found in the Content Pipeline extension project is because that library does not exist at runtime! The content importer is not even part of the XNA Framework used at runtime, so you cannot put any class into the extension library project that you need to use at runtime. For that purpose, we have a second library that reads the XNA file and makes it available to Content.Load. This new class is called TextReader (note the namespace). See Figure 5.5.

Figure 5.5. Adding a Content Reader class to the secondary library project.

using System;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;

using TRead = GameLibrary.MyData;

namespace GameLibrary
{
    public struct MyData
    {
        public string MyString;
    }

    public class TextReader : ContentTypeReader<TRead>
    {

        protected override TRead Read(ContentReader input,
            TRead existingInstance)
        {
            //read the .xnb file
            GameLibrary.MyData data = new GameLibrary.MyData();
            data.MyString = input.ReadString();
            return data;
        }
    }
}