Tweetinvi, an intuitive Twitter C# library for the REST and Stream API. It supports .NET, .NETCore, UAP (Xamarin)...
Tweetinvi 5.0 is a major refactor of Tweetinvi. The new version introduces the TwitterClient which lets you perform all operations based on a fixed set of credentials. The change let us resolved various core problematics that arised with the evolution of the .NET Framework including async/await and ASP.NETCore execution contexts.
Here are some of the major changes.
Tweetinvi is now using the Async/Await pattern in its entire code base. This will help modern development and ease up ASPNET thread pool.
The TwitterClient gives you better control over who is executing a request. Also it gives developers the ability to pass the client through the code.
Support of all the endpoints of Twitter API V2!
Developers no longer have to search for endpoints available parameters. Tweetinvi contains all the parameters from the official documentation and all the parameters missing from the official documentation :D
Iterators are a new way to use paging in Twitter in a single and unique way. Developers no longer need to understand the 4 types of paging from Twitter API, Tweetinvi takes care of it for you!
Tweetinvi documentation has been at the core of the new version.
- The new documentation should explain provide examples for all the bits and pieces you can find in the Tweetinvi library.
- All publicly available code has been annotated to explain what each method do and what they return.
A lot of work has been done to simplify the Account Activity process and make it as easy as possible for developers to start using it.
Tweetinvi 5.0 has been built for .NETStandard 1.4 and .NETStandard 2.0 which should make it compatible for most of the existing .NET environments!
Some endpoints were missing from the library. All endpoints in the Twitter documentation are now officially supported.
Exceptions have never been a strong part of Tweetinvi. This has changed and Tweetinvi is now throwing a very limited set of Exceptions.
Twitter API endpoints are managing response formats, status codes, headers, response, error messages in different ways. Tweetinvi now takes care of all the special cases for you and handle these cases as you would expect hiding the complexity behind a simple API.
5.0 was also a chance to fix a long list of bugs, including multithreading, missing data, unhandled cases, non matching criteria and many more...
Tweetinvi 5.0 uses integration tests to verify that the code base is properly working. Not only does this give us a better view on the state of the library but also let you discover how to use the library!
Performance improvements, upload support, parameters validation, namespaces/code cleanup, dependencies updates, .NETCore support...
Tweetinvi 5.0 is the result of more than a year of work, countless hours and more than 350 commits so I hope you will appreciate using the new version.
I take this opportunity to thanks @JoshKeegan for his special contributions to the project.
I look forward to hearing your feedback!
New version of the Direct Message API implies lots of changes, please read them in the New Direct Message API section below
UserEventArgs.User has changed to UserEventArgs.Target. This was needed as we introduced a way to differentiate SourceId and Target.
Stream.TweetDeleted event argument has changed to a new format to be compatible with new Account Activity Stream.
public class TweetDeletedEventArgs : EventArgs
{
public long TweetId { get; set; }
public long UserId { get; set; }
public long? Timestamp { get; set; }
}
AuthenticatedUser.GetLatestMessagesReceived -> AuthenticatedUser.GetLatestMessages
Tweetinvi now supports the new Direct Message API.
Behind the scenes a lot has changed as, the queries to be performed are different as well as the object formats and the logic necessary to handle it.
A special note to say thank you to @JoshKeegan who has been the main developer to help bringing this feature to life.
IMessage interface has changed significantly:Deleted properties
Twitter has reduced the number of information they in the message payload as a result some information that were current available does not exist anymore.
message.MessageDTO and has been replaced with message.EventDTO
message.Sender is no longer available. You now only have access to SenderId
message.SenderScreenName is no longer availablemessage.Recipient is no longer availablemessage.RecipientScreenName is no longer availablemessage.IsMessagePublished is no longer availableNew properties
message.App property now returns the information of the app used to create the messagemessage.InitiatedViaTweetId
message.InitiatedViaWelcomeMessageId
message.QuickReplyResponse
message.AttachedMedia
Renamed properties
message.IsMessageDestroyed -> message.IsDestroyed
Message.GetLatestMessagesReceived has been renamed Message.GetLatestMessages as there is now only a single endpoint to get the latest messages.PublishMessageParameters constructor is now only taking a userId as second parameter (recipientId). screenName is no longer supported.
You can now publish a message with a Media attached to it (doc)
You can now publish a message with a Quick Response (doc)
// Messages Sent or received
var latestMessages = Message.GetLatestMessages(TweetinviConsts.MESSAGE_GET_COUNT, out string cursor);
// Check for a cursor having been returned, if not, there's no more results
if (cursor == null)
{
return;
}
var latestMessagesParameters = new GetMessagesParameters()
{
Count = 20,
Cursor = 20
};
var latestMessagesFromParameters = Message.GetLatestMessages(latestMessagesParameters, out cursor);
// ...
Message.GetLatestMessages will be improved with a new logic to manage cursor queries.Twitter is deprecating user stream and site stream. As a result, your app will no longer be able to create a stream to get live feed events for a specific user.
After the 18/08/2018, UserStream will no longer be available and will be replaced by AccountActivity.
AccountActivity will handle live events from Twitter by analyzing Twitter requests sent to your Webhook.
To use webhooks with Tweetinvi, you will need to use the following nuget package :
A webhook is a http callback. You send to Twitter the url of an http server and Twitter will use that url to execute requests that will represent different events.
It means that you no longer need multiple streams to handle multiple users but just a single server that Twitter can communicate with to send you live updates.
Useful links :
Plugins is a new way to register additional package that will work with Tweetinvi.
This is for example the case of the WebhooksModule that will later be created as a plugin because it is dependent with the Microsoft.AspNetCore.All package.
Plugins must be registered before any operation is executed by Tweetinvi.
// Before any operation with Tweetinvi you can add a plugin as followed.
Plugins.Add<WebhooksModule>();
AuthenticatedUser.GetLatestMessagesReceived has been renamed to AuthenticatedUser.GetLatestMessages as there is now only a single endpoint to get the latest messages.Tweet has now 2 new fields ReplyCount and QuoteCount.
GetPlaceTrendsAt no longer throws an exception if the query failed. It returns null as the others.GeoCode is now properly behavingTrend.TweetVolume property is now a long
Upload is the major change in the version. For more consistency and have an easier way to handle the different scenarios the library has been widely modified.
Upload now only has 2 endpoints : UploadBinary and UploadVideo.
Both endpoints can take a simple byte[] binary parameter.
var media = Upload.UploadBinary(binary);
var video = Upload.UploadVideo(binary);
You can also specify all the optional parameters as part of your request :
UploadStateChanged
Upload.UploadBinary(binary, new UploadOptionalParameters
{
UploadStateChanged = (stateChangedArgs) =>
{
Console.WriteLine($"{stateChangedArgs.State} : {stateChangedArgs.Percentage}%");
}
});
WaitForTwitterProcessing
Ensure that when the media is returned by Tweetinvi it can directly be used in any new request. The reason for such a parameter is that videos and gifs have to be processed by Twitter beforehand the media can be used in a Tweet.
MediaType
MediaType = MediaType.VideoMp4
QueryMediaType
// To support any media type that would not be available as part
// of the MediaType enum you can use
QueryMediaType = "video/mp4"
MediaCategory
MediaType = MediaType.Gif
QueryMediaCategory
// To support any media category that would not be available as part
// of the MediaCategory enum you can use
QueryMediaType = "gif"
Timeout
Duration before cancelling a request.
MaxChunkSize
Custom binary chunk size to be sent to Twitter.
AdditionalOwnerIds
To specify who can use the uploaded media.
You can add some custom parameters to the InitCustomRequestParameters and AppendCustomRequestParameters properties to support any new parameters.
Improved support for unicode. This will now provide more accurate result for Prefix and Suffix as well as better length calculation.
The extended mode has been there for a while now and Tweetinvi will now be using this mode by default.
TweetinviConsts.MAX_TWEET_SIZE is now 280 and can now be modified by the developers.
As part of the Upload refactoring the methods PublishTweetWithMedia and PublishTweetWithVideo are no longer available use the parameters instead :
var media = Upload.UploadBinary(binary);
Tweet.PublishTweet("hello", new PublishTweetOptionalParameters()
{
Medias = { media }
});
Twitter has recently changed their algorithm to calculate the length of a Tweet. The changes involved are significant and therefore result in Tweetinvi algorithm to no longer be 100% aligned with their logic. Some improvements have been done for Unicode calculation but it is still no aligned on other changes.
As a result I would recommend that you use the official Twitter library to calculate a Tweet length.
The best approach to use this this, would be to create a simple node.js microservice that would simply return the tweet length. And you would consume this service via any protocol from your C# application.
List of breaking changes :
// NO LONGER EXIST
// ---- From a Tweet Instance
var length = tweet.CalculateLength(bool);
var length = tweet.PublishedTweetLength;
// ---- From the Tweet static
var length = Tweet.Length();
// ---- From string or StringExtension
var length = string.TweetLength(...); // is now
var length = StringExtension.Length(...);
If nevertheless you want to keep using Tweetinvi's logic you can use the obsolete method from the StringExtension
// namespace Tweetinvi.Core.Extensions
var length = StringExtension.EstimateTweetLength(...);
At some point I will create a node.js project that you could use (probably after version 5.0).
MediaEntities of Messages
The new Xamarin projects are now targeting .NETStandard 4 and as a result Tweetinvi is now targeting .NETStandard 4. It also means that Tweetinvi will no longer support .NET Framework 4.6 but will now start the support at .NET Framework 4.6.1.
The library is strong named and all dependencies are also strongly named.
To follow the globally used semantic versioning Tweetinvi 2.2 is now called Tweetinvi 3.0 and all future updates of the library with breaking changes will now be creating a new Major version.
Account.UpdateAccountProfile is now properly updating if some values contain commas or special characters$ characterTweetinviSettings is now being set with the same settings used by the Thread invoking any async action with Sync.ExecuteTaskAsync.
TweetinviSettings.TweetMode = TweetMode.Compat;
var homeTimeline = await Sync.ExecuteTaskAsync(() =>
{
// Here the tweets will be retrieved with TweetMode.Compat
// because the calling thread uses such config
return Timeline.GetHomeTimeline();
});
You can now add your own http headers to any query performed by the library using TweetinviEvents.
// Use the gzip compression
TweetinviEvents.QueryBeforeExecute += (e, args) =>
{
args.TwitterQuery.CustomHeaders.Add("Accept-Encoding", "gzip");
}
Tweetinvi length calculation used to check for character size based on the number of bytes that each grapheme required.
With further investigation it appeared that Twitter is not handling some Emojis the same way.
I have therefore tried to improve the logic to match the logic from Twitter.
This is particularly relevant for some of the new extended tweets properties like Suffix and DisplayRange.
If you encounter some mismatch between what Twitter is returning and what Tweetinvi returns in terms of a Tweet Text please open an issue.
When uploading content you can now pick the type of content you want to send from the UploadMediaCategory enum.
In addition to this, Upload.UploadVideo is no longer using amplify_video by default but tweet_video
which is the only one supporting video larger than 15mb.
A new static method has been added to Upload so that you can specify the type of media category you wish to use.
IMedia UploadVideo(byte[] binary, UploadMediaCategory mediaCategory)
TweetinviEvents.QueryAfterExecute will now provide the actual exception if any occurred.
Previously only the status code of the error was returned. This should simplify error logging for some developers.
TweetinviEvents.QueryAfterExecute += (e, args) =>
{
var exception = args.Exception;
// Do whatever you want with it :)
};
List memberships endpoint is now part of the library :
var twitterMemberships = TwitterList.GetUserListMemberships("twitter");
All the example projects have been retested, upgraded and description have been added. All the projects compatible with Visual Studio for Mac have also been tested.
The Universal App project has been tested on Raspberry Pi 3 with Windows 10 iot.
You will also find 2 new projects for
In order for the library to be the most compatible with the different application types and versions of .NET, I have removed the dependency to System.Type.Primitives
Tweet.Suffix for tweets with a display range length of 0 is now properly returned.AuthFlow.InitAuthenticationProcess is now supporting oauth_callback_confirmed being
returned as a string.TwitterList.GetExistingList is now properly validating the provided parameters (either the id or slugname needs to be provided).Tweetinvi has been a Portable Class Library (PCL) since 2014 in order to help C# developers to use Twitter in Mono and then in Xamarin.
With .NetStandard PCL will progressively being migrated to .NETStandard libraries and this is why Tweetinvi is no longer a PCL.
During this migration I had to make choices regarding the target. Initially I wanted to keep targeting .NETStandard 1.0 and .NETFramwork 4.0.
Unfortunately I was not able to do so and the minimum target of Tweetinvi 2.0 and later will be .NETStandard 1.3 and .NETFramework 4.6.
async has been integrated in .NETFramework 4.5.The new solution includes various new sample projects that you can reuse to start your project. At the time of this release you can find the following :
Console Application for .NET Framework (Examplinvi.NETFramework)
Console Application for .NET Core (Examplinvi.NETStandard)
MVC web project using .NET Framework (Examplinvi.ASP.NET)
MVC web project using .NET Core (Examplinvi.ASP.NET.Core)
Xamarin Android App (Examplinvi.Xamarin.Android)
Xamarin iOS App (Examplinvi.Xamarin.iOS)
Windows Universal App (Examplinvi.UAP)
Other samples will come in the future. I am currently thinking of WPF and RaspberryPi.
A critical bug regarding async and multithreading where the Task completion callback Thread was not the calling thread. This issue was happening in application without any SynchronizationContext like console application.
You can read more about it on the bug at : https://github.com/linvi/tweetinvi/issues/473.
By default Tweetinvi should install properly to ALL type of projects with the proper .NET targets.
In some cases the installation of the System.Net.Http and System.Runtime.Serialization.Primitives dependencies can result in dependency conflicts over the version of the DLL to use.
If you encounter an Exception stating that the library System.Net.Http or System.Runtime.Serialization.Primitives could not be found, please add the following configuration in your web.config.
<dependentAssembly>
<assemblyIdentity name="System.Runtime.Serialization.Primitives" publicKeyToken="B03F5F7F11D50A3A" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-4.1.2.0" newVersion="4.1.2.0" />
</dependentAssembly>
<dependentAssembly>
<assemblyIdentity name="System.Net.Http" publicKeyToken="B03F5F7F11D50A3A" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-4.1.1.1" newVersion="4.1.1.1" />
</dependentAssembly>
These lines should be added under the <runtime> <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">.
var proxyConfig = new ProxyConfig("http://192.168.1.1", new NetworkCredential("username", "password"));
TweetinviConfig.CurrentThreadSettings.ProxyConfig = proxyConfig;
Improved the selection of entities to provide based on whether a Tweet mode is compat or extended. The entities provided will now be unique will provide accurate indices based on the mode of the Tweet. A TweetMode property has been added to the Tweet to let the users know what type of Tweet they are using.
Streams are now matching QuotedTweets.
Fixed typo : SubsribeToList has been updated to SubscribeToList
The exclude_reply_user_ids parameter has now been added to the parameters for publishing a new Tweet. This parameter will be used if the auto_populate_reply_metadata is set to false.
Tweets contains a new property TweetMode allowing the developers to know how a Tweet has been retrieved.
QuotedTweets. You can get access to QuotedTweet matching in the MatchingTweetReceived.var fs = Stream.CreateFilteredStream();
fs.MatchingTweetReceived += (sender, args) =>
{
var quotedTweetMatchedOn = args.QuotedTweetMatchOn;
var matchingTracks = args.QuotedTweetMatchingTracks;
var matchingFollowers = args.QuotedTweetMatchingFollowers;
var matchingLocations = args.QuotedTweetMatchingLocations;
};
FilteredStreams now provide a new CheckIfTweetMatchesStreamFilters that allow the developers to know on what a Tweet is matching some criteria.
Streams have a new event called KeepAliveReceived that inform the developers that Twitter has sent a KeepAlive event.
InitializeApplicationBearer now returns a boolean indicating whether the operation has been a success.ITwitterRequestParameters) that can be used to transfer a query to another client securely. The query will be created and signed on the server and executed on another consumer.You can find this method on the TwitterAccessor
ITwitterRequestParameters GenerateTwitterRequestParameters(string url, HttpMethod method, ITwitterCredentials credentials, HttpContent httpContent)
UserStream for users with more than 10k users properly handle the FOLLOWS_OVER_LIMIT event.- in urls.Thread Credentials sectionITweet.Entities property. as opposed to before when the property was returning both Extended Entities AND Legacy EntitiesWith the addition of .NETCore to nuget targets for the library, some people started to experience problems regarding the dependencies that were added based on their platforms specifically for Xamarin and Mono. We are pleased to announce that this has been fixed and in addition projects with classical .NET Framework will be able to use Autofac >= 3.5.2 again.
TweetEventArgs now return an ITweet and its associated json to simplify the life of developers!
To improve the flexibility of Tweetinvi, ITwitterQuery now provide a new property AcceptHeaders that you can update to customize the Accept headers that will be used to execute the HttpRequest.
You can now access private message entities via the IMessage.Entities property.
A new method allow you to rely on Tweetinvi to synchronously wait for a media to be uploaded and processed by the Twitter Upload API.
var binary = File.ReadAllBytes(@"C:\Users\linvi\Pictures\sample_video.mp4");
var media = Upload.UploadVideo(binary, mediaCategory: "amplify_video");
// The media cannot be used for the moment.
var mediaWithMetadata = Upload.WaitForMediaProcessingToGetAllMetadata(media);
// Now we can access the media's metadata.
var videoType = mediaWithMetadata.UploadedMediaInfo.VideoDetails.VideoType;
This topic is about threads and is slightly more technical than usual, please read attentively.
T1 are being used to invoke methods from another thread T2 (T1 and T2 having a different set of credentials)Most developers uses Auth.SetUserCredentials in order to set the credentials used within the current running thread. Any object (tweet, user, message...) created in the context of this thread are being constructed with injected controllers/factories/helpers.
Before version 1.2 a newly created object was storing a controller that helped him execute any operation related with this object type (e.g. ITweet objects are capable of invoking a PublishRetweet() method).
The problem was that the controller within the newly object had an indirect reference to the credentials of the thread used for the creation of the object.
Therefore invoking tweet.PublishRetweet in a thread T2 different from the constructor thread T1, incorrectly resulted in the credentials of T1 to be used to run PublishRetweet whilst developers would have expected the credentials of T2 to be used to run the instance method.
In version 1.2 PublishRetweet correctly uses the running thread T2 credentials.
ITweet tweet = null;
var T1 = new Thread(() =>
{
// We initialize the T1 credentials
Auth.SetUserCredentials(creds1);
// We have a tweet that was created with T1
tweet = Tweet.PublishTweet("hello");
});
T1.Start();
// The tweet variable is now an instance of ITweet
T1.Join();
// We initialize the credentials of the main thread T2
Auth.SetUserCredentials(creds2);
// Here is where the bug happened before 1.2
// PublishRetweet was running with creds1 (T1) instead of creds2
// In version 1.2, this operation will be executed with creds2
tweet.PublishRetweet();
PublishTweetParameters.ExcludeReplyUserIds
UploadProcessingInfo is now an enum that help developers to know the current stage of an upload.LanguageAttribute that you can use to retrieve its main Name or all the Names it is associated with.Account.GetMultipleRelationships has been renamed Account.GetRelationshipsWith.Tweetinvi for .NET Core is now available through the TweetinviApi nuget package.
Tweetinvi now provide a very simple tool to serialize and deserialize objects.
The JsonSerializer is a new static class that will give you the ability to serialize any Tweetinvi model into a string. It also give you the ability to deserialize this same string back into the object type or in its DTO implementation.
// Get tweet from Twitter
ITweet tweet = Tweet.GetTweet(778303039111368706);
// Serialize Tweet
string jsonTweet = JsonSerializer.ToJson(tweet);
// Deserialize Tweet into ITweet
ITweet deserializedTweet = JsonSerializer.ConvertJsonTo<ITweet>(jsonTweet);
// Deserialize Tweet into DTO
ITweetDTO deserializedTweetDTO = JsonSerializer.ConvertJsonTo<ITweetDTO>(jsonTweet);
Note that these classes are extension methods.
// Same code with extension methods.
ITweet tweet = Tweet.GetTweet(778303039111368706);
string jsonTweet = tweet.ToJson();
ITweet deserializedTweet = jsonTweet.ConvertJsonTo<ITweet>();
ITweetDTO deserializedTweetDTO = jsonTweet.ConvertJsonTo<ITweetDTO>();
The Language enum has been improved to provide more information to the users. Its associated LanguageAttribute now gives you the following information :
Twitter does not allow developers to filter tweets based on all the existing Languages.
The Language enum that was used previously by Tweetinvi to filter streams and searches has been replaced by the LanguageFilter enum.
ITweet.Language has not been affected and is still using the Language enum.
Language lang = args.Tweet.Language;
// Get only French tweets
var tweets = Search.SearchTweets(new SearchTweetsParameters("tweetinvi")
{
Lang = LanguageFilter.French
});
// Get only French tweets
stream.AddTweetLanguageFilter(LanguageFilter.French);
// Remove the French filter
stream.RemoveTweetLanguageFilter(LanguageFilter.French);
Tweetinvi search now contains a new parameter FilterTweetsNotContainingGeoInformationthat give you the ability to only receive tweets that contain a Place or Coordinates when requesting tweets published at a specific Geo location.
var tweets = Search.SearchTweets(new SearchTweetsParameters("tweetinvi")
{
GeoCode = new GeoCode(/*...*/),
FilterTweetsNotContainingGeoInformation = true
});
This feature has been provided for a future version of Twitter. Currently Twitter does protect some binary downloads with OAuth. This new feature allow you to download such binaries.
You can for example try to use it to download private messages media.
IMPORTANT NOTE: this is not supported by Twitter and you can receive an exception or the returned binary can be invalid.
var binary = TwitterAccessor.DownloadBinary("https://twitter.com/...");
GetFavoritesAsync now has an overload taking a GetUserFavoritesParameters.HttpMethod enum now supports more Ads endpoint with newly added DELETE and PUT actions.ITweet.Media.Variants.ContentType is now properly populated.UpdateList is no longer throwing an Unauthorized exception.After 4 years of development we are finally releasing the first major version. We've communicated with many of you, participated in your projects in order to understand how to guide this project. Therefore I would like to make a big thank you to all of you who have participated to make this release possible.
That said, I hope you will love this latest release.
Generate Parameters have been deleted. Use new Parameter() instead. (learn more).Publish methods taking Tweet or Message have now been removed. (learn more).Tweetinvi libraries released will now be signed by certificates. This will allow companies to ensure that the library is an "official" build.
Our focus for version 1.0 was to improve the library to make it easier and faster to use. We wanted to have a global library that made sense. With this goal in mind we have improved lots of classes/interfaces namespaces, we have removed some redundant methods and finally we have improved the in code documentation.
For this release 1.0, we wanted to make sure that users were able to have a clear overview of the namespaces they need when using the library.
We have therefore greatly reduced the number of using statement required and consolidated them into major comprehensive groups.
You can learn more about the namespaces in the documentation.
All the generate methods that were used to create parameters have now been removed to promote the ability for developers to create the same parameters using the new keyword.
List of changes :
User.GenerateUserIdentifierFromId is no longer available. Please use new UserIdentifier instead.Geo.GenerateGeoCode is no longer available. Please use new GeoCode instead.Tweet.GenerateOEmbedTweet has been renamed Tweet.GetOEmbedTweet
Message.CreateGetLatestsReceivedRequestParameter has been removed. Use new MessagesReceivedParameters() instead.Message.CreateGetLatestsSentRequestParameter has been removed. Use new MessagesSentParameters() instead.For historic reasons, Tweetinvi kept using old methods that allowed developers to create a local (and unpublished) version Tweet or a Message and then actually publish it based on some of its properties.
To make it clear of which properties Tweetinvi is using we have now deleted such methods. Developers will be able to publish using Parameters objects containing all the available parameters that can be use to define how to publish.
Below you can find a list of changes :
Tweet.Publish(ITweet) no longer exist. Use Tweet.PublishTweet(IPublishTweetParameters) insteadnew PublishMessageParameters(IMessageDTO) no longer exists. Use the other constructor overloads instead.Extended Tweet should be released in the coming months. Version 0.9.14.0 is a first version trying to address most of the concepts introduced by this new type of Tweets.
First of all I would like to mention that Tweetinvi support of Extended Tweet does not mean that it does no longer support the current version of the Twitter API.
The code has been thought of so that Tweetinvi can handle both versions safely.
ITweet includes new properties that you can use to extract the information from an extended tweet.
var tweet = Tweet.PublishTweet("@tweetinviapi forever! pic.twitter.com/42");
var fullText = tweet.FullText; // @tweetinviapi forever!
var prefix_or_mentions = tweet.Prefix; // @tweetinviapi
var content = tweet.Text; // forever!
var suffix = tweet.Suffix; // pic.twitter.com/42
You can also access some other metadata like :
int[] tweet.DisplayTextRange; // Contains the location of the text to display (content).
IExtendedTweet tweet.ExtendedTweet; // Contains all the information specific to extended tweets.
Twitter introduced a TweetMode that is either compat or extended. To make it simpler for developers, they will be able to set this value directly from the TweetinviConfig for the lifetime of a thread of for the entire application.
TweetinviConfig.CurrentThreadSettings.TweetMode = TweetMode.Extended;
Note that by default this value will be null. When not set, Tweetinvi will not add the tweet_mode parameter to any of the endpoints that can use it.
In addition to this, the auto_populate_reply_metadata has been added to the PublishTweetOptionalParameters class.
To preview how a string will be divided you can use the new string extension method TweetParts().
string tweet = "@tweetinviapi Amazing!";
ITweetParts tweetParts = tweet.TweetParts();
string prefix = tweetParts.Prefix;
string content = tweetParts.Content;
int twitterLength = tweetParts.Content.TweetLength();
string[] mentions = tweetParts.Mentions;
NOTE : TweetParts are only to be used with text that is intended to be used with tweet_mode extended and in reply to another tweet.
The extended entities will be merged into the Entities property automatically.
Some developers want their app to work in an uncontrolled environment like mobile phones. In such environment, we do not have any control in regards to the DateTime/Timezone configuration. As Twitter requires its request to be signed with a UTC datetime, developers can now decide how they want to retrieve this information (accessing the value from an external website for example).
TweetinviConfig.CurrentThreadSettings.GetUtcDateTime = () =>
{
return DateTime.UtcNow.Subtract(TimeSpan.FromHours(1));
};